സെഷനുകൾക്കിടയിൽ Php ട്രാൻസ്ഫർ ഡാറ്റ. സെഷനുകൾ ആക്സസ് ചെയ്യുന്നതിനുള്ള പ്രവർത്തനങ്ങൾ. സെഷൻ ജോലിയുടെ ഉദാഹരണങ്ങൾ

സെഷൻ ആക്സസ് പ്രവർത്തനങ്ങൾ

PHP-യിലെ സെഷൻ പിന്തുണ എന്നത് തുടർച്ചയായ ആക്സസുകളിലുടനീളം നിർദ്ദിഷ്ട ഡാറ്റ സംഭരിക്കുന്നതിനുള്ള ഒരു മാർഗമാണ്. കൂടുതൽ പ്രത്യേക ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കാനും നിങ്ങളുടെ വെബ്‌സൈറ്റിൻ്റെ ആകർഷണം വർദ്ധിപ്പിക്കാനും ഇത് സാധ്യമാക്കുന്നു.

PHPLIB ഉപയോഗിച്ച് സെഷനുകൾ പരിപാലിക്കുന്നത് നിങ്ങൾക്ക് പരിചിതമാണെങ്കിൽ, ചില പ്രശ്നങ്ങൾ PHP-യിൽ സെഷനുകൾ പരിപാലിക്കുന്നതിന് സമാനമാണെന്ന് നിങ്ങൾ ശ്രദ്ധിക്കും.

നിങ്ങളുടെ സൈറ്റിലേക്കുള്ള ഒരു സന്ദർശകന് സെഷൻ ഐഡി എന്ന് വിളിക്കപ്പെടുന്ന ഒരു അദ്വിതീയ ഐഡി നൽകിയിട്ടുണ്ട്. ഇത് ഉപയോക്തൃ വശത്തുള്ള ഒരു കുക്കിയിൽ സംഭരിക്കുകയോ URL-ലേക്ക് കുത്തിവയ്ക്കുകയോ ചെയ്യുന്നു.

സെഷൻ പിന്തുണ നിങ്ങൾക്ക് വേരിയബിളുകളുടെ അനിയന്ത്രിതമായ എണ്ണം രജിസ്റ്റർ ചെയ്യാനും അന്വേഷണ നിർവ്വഹണങ്ങൾക്കിടയിൽ അവ സംരക്ഷിക്കാനുമുള്ള കഴിവ് നൽകുന്നു. ഒരു ഉപയോക്താവ് നിങ്ങളുടെ സൈറ്റിൽ പ്രവേശിക്കുമ്പോൾ, PHP ഒന്നുകിൽ സ്വയമേവ (seation.auto_start 1 ആയി സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ) അല്ലെങ്കിൽ നിങ്ങളുടെ അഭ്യർത്ഥന പ്രകാരം (വ്യക്തമായി - വഴി സെഷൻ_ആരംഭം()അല്ലെങ്കിൽ പരോക്ഷമായി - വഴി സെഷൻ_രജിസ്റ്റർ()) അഭ്യർത്ഥനയ്‌ക്കൊപ്പം ഒരു പ്രത്യേക സെഷൻ ഐഡി അയച്ചിട്ടുണ്ടോയെന്ന് പരിശോധിക്കുക. അങ്ങനെയെങ്കിൽ, മുമ്പത്തെ പരിസ്ഥിതി പുനഃസൃഷ്ടിക്കപ്പെടുന്നു.

അഭ്യർത്ഥന അവസാനിച്ചതിന് ശേഷം രജിസ്റ്റർ ചെയ്ത എല്ലാ വേരിയബിളുകളും ക്രമീകരിച്ചിരിക്കുന്നു. രജിസ്റ്റർ ചെയ്ത നിർവചിക്കാത്ത വേരിയബിളുകൾ നിർവചിക്കാത്തതായി അടയാളപ്പെടുത്തിയിരിക്കുന്നു. തുടർന്നുള്ള അഭ്യർത്ഥനകളിൽ, ഉപയോക്താവ് അവ പിന്നീട് നിർവചിക്കുന്നില്ലെങ്കിൽ സെഷൻ മൊഡ്യൂൾ അവ നിർണ്ണയിക്കില്ല.

$_SESSION (അല്ലെങ്കിൽ PHP 4.0.6 അല്ലെങ്കിൽ അതിന് മുമ്പുള്ളതിൽ $HTTP_SESSION_VARS) ഉപയോഗിക്കുന്നത് സുരക്ഷാ കോഡ് റീഡബിലിറ്റി കാരണങ്ങളാൽ ശുപാർശ ചെയ്യുന്നു. $_SESSION അല്ലെങ്കിൽ $HTTP_SESSION_VARS വേരിയബിളുകൾ ഉണ്ടെങ്കിൽ, session_register()/session_unregister()/session_is_registered() ഫംഗ്ഷനുകൾ ഉപയോഗിക്കേണ്ടതില്ല. ഉപയോക്താക്കൾക്ക് ഒരു സാധാരണ വേരിയബിളായി സെഷൻ വേരിയബിൾ ആക്സസ് ചെയ്യാൻ കഴിയും.

ഉദാഹരണം 2: $_SESSION ഉപയോഗിച്ച് ഒരു വേരിയബിൾ അൺരജിസ്റ്റർ ചെയ്യുന്നു

സെഷൻ_ആരംഭം();
// PHP 4.0.6 അല്ലെങ്കിൽ അതിൽ കുറവുള്ള $HTTP_SESSION_VARS ഉപയോഗിക്കുക
സജ്ജമാക്കാത്തത്($_SESSION [ "count" ]);
?>

ശ്രദ്ധ!

നിങ്ങൾ $HTTP_SESSION_VARS / $_SESSION ഉപയോഗിക്കുകയും രജിസ്റ്റർ_ഗ്ലോബലുകൾ പ്രവർത്തനരഹിതമാക്കുകയും ചെയ്തിട്ടുണ്ടെങ്കിൽ, ഉപയോഗിക്കരുത്. സെഷൻ_രജിസ്റ്റർ() , session_is_registered()ഒപ്പം session_unregister() .

URL പാരാമീറ്റർ

സെഷൻ മോഡൽ രണ്ട് രീതികളും പിന്തുണയ്ക്കുന്നു. കുക്കികൾ ഒപ്റ്റിമൽ ആണ്, പക്ഷേ അവ സുരക്ഷിതമല്ലാത്തതിനാൽ (ഉപഭോക്താക്കൾ അവ സ്വീകരിച്ചേക്കില്ല), ഞങ്ങൾക്ക് അവയിൽ ആശ്രയിക്കാനാവില്ല. രണ്ടാമത്തെ രീതി സെഷൻ ഐഡി നേരിട്ട് URL-ൽ ഉൾച്ചേർക്കുന്നു.

--enable-trans-sid ഓപ്ഷൻ ഉപയോഗിച്ച് കംപൈൽ ചെയ്യുമ്പോൾ PHP യ്ക്ക് ഇത് സുതാര്യമായി ചെയ്യാൻ കഴിയും. നിങ്ങൾ ഈ ഓപ്‌ഷൻ പ്രവർത്തനക്ഷമമാക്കുകയാണെങ്കിൽ, സെഷൻ ഐഡി സ്വയമേവ ഉൾപ്പെടുത്തുന്നതിന് ആപേക്ഷിക യുആർഐകൾ മാറും. പകരമായി, നിങ്ങൾക്ക് SID സ്ഥിരാങ്കം ഉപയോഗിക്കാം, ക്ലയൻ്റ് പൊരുത്തപ്പെടുന്ന കുക്കി അയച്ചിട്ടില്ലെങ്കിൽ അത് നിർവചിക്കപ്പെടുന്നു. SID എന്നത് session_name=session_id അല്ലെങ്കിൽ ഒരു ശൂന്യമായ സ്‌ട്രിംഗിൻ്റെ രൂപമാണ്.

കുറിപ്പ്: arg_separator.output php.ini നിർദ്ദേശം ആർഗ്യുമെൻ്റ് സെപ്പറേറ്ററിനെ പ്രത്യേകമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

ഇനിപ്പറയുന്ന ഉദാഹരണം ഒരു വേരിയബിൾ എങ്ങനെ രജിസ്റ്റർ ചെയ്യാമെന്നും SID ഉപയോഗിച്ച് മറ്റൊരു പേജുമായി എങ്ങനെ ശരിയായി ബന്ധപ്പെടാമെന്നും കാണിക്കുന്നു.

ഉദാഹരണം 5: ഒരു വ്യക്തിഗത ഉപയോക്താവിനുള്ള ലോഗിനുകളുടെ എണ്ണം കണക്കാക്കുന്നു

എങ്കിൽ (! session_is_registered ("count")) (
സെഷൻ_രജിസ്റ്റർ ("എണ്ണം");
$count = 1 ;
) വേറെ (
$count++;
}
?>

ഹലോ സന്ദർശകൻ, നിങ്ങൾ ഈ പേജ് കണ്ടുതവണ.

തുടരാൻ, ">ക്ലിക്ക് ചെയ്യുക
ഇവിടെ.

PHP കംപൈൽ ചെയ്യുമ്പോൾ --enable-trans-sid ഉപയോഗിച്ചിരുന്നെങ്കിൽ SID?> ആവശ്യമില്ല.

കുറിപ്പ്:റിലേറ്റീവ് അല്ലാത്ത URL-കൾ ബാഹ്യ സൈറ്റുകളിലേക്കാണ് വിരൽ ചൂണ്ടുന്നത്, അതിനാൽ SID-കൾ അറ്റാച്ചുചെയ്യരുത്, കാരണം മറ്റൊരു സെർവറിലേക്ക് SID വിവരങ്ങൾ ചോർത്താൻ സാധ്യതയുണ്ട്.

ഡാറ്റാബേസ് സ്റ്റോറേജ് അല്ലെങ്കിൽ മറ്റ് രീതികൾ നടപ്പിലാക്കാൻ നിങ്ങൾ ഉപയോഗിക്കേണ്ടതുണ്ട് session_set_save_handler()ഉപയോക്തൃ-തല സംഭരണ പ്രവർത്തനങ്ങളുടെ ഒരു കൂട്ടം സൃഷ്ടിക്കാൻ.

കോൺഫിഗറേഷൻ

ഡിഫോൾട്ട് കോൺഫിഗറേഷൻ നിർദ്ദേശങ്ങൾ നോക്കാം:

നിർദ്ദേശത്തിൻ്റെ പേര്	സ്ഥിര മൂല്യം	കുറിപ്പുകൾ
session.save_path	""
സെഷൻ.പേര്	"PHPSESSID"
session.save_handler	"ഫയലുകൾ"
session.auto_start	"0"
session.gc_probability	"1"
session.gc_divisor	"100"	PHP 4.3.2-ൽ നിന്ന് ലഭ്യമാണ്.
session.gc_maxlifetime	"1440"
session.serialize_handler	"php"
session.cookie_lifetime	"0"
session.cookie_path	"/"
session.cookie_domain	""
session.cookie_secure	""	PHP 4.0.4-ൽ നിന്ന് ലഭ്യമാണ്.
session.use_cookies	"1"
session.use_only_cookies	"0"	PHP 4.3.0-ൽ നിന്ന് ലഭ്യമാണ്.
session.referer_check	""
session.entropy_file	""
session.entropy_length	"0"
session.cache_limiter	"നോകാഷെ"
session.cache_expire	"180"
session.use_trans_sid	"0"	PHP 4.0.3-ൽ നിന്ന് ലഭ്യമാണ്.
session.bug_compat_42	"1"	PHP 4.3.0-ൽ നിന്ന് ലഭ്യമാണ്.
session.bug_compat_warn	"1"	PHP 4.3.0-ൽ നിന്ന് ലഭ്യമാണ്.
session.hash_function	"0"	PHP 5.0.0-ൽ നിന്ന് ലഭ്യമാണ്.
session.hash_bits_per_character	"4"	PHP 5.0.0-ൽ നിന്ന് ലഭ്യമാണ്.
url_rewriter.tags	"a=href,area=href,frame=src,form=,fieldset="	PHP 4.0.4-ൽ നിന്ന് ലഭ്യമാണ്.

സെഷൻ മാനേജ്മെൻ്റ് സിസ്റ്റം നിങ്ങളുടെ php.ini ഫയലിൽ സ്ഥാപിക്കാൻ കഴിയുന്ന നിരവധി കോൺഫിഗറേഷൻ ഓപ്ഷനുകളെ പിന്തുണയ്ക്കുന്നു. ഞങ്ങൾ ഒരു ഹ്രസ്വ അവലോകനം നൽകും.

സെഷനുമായി ബന്ധപ്പെട്ട ഡാറ്റ സംഭരിക്കുന്നതിനും അഭ്യർത്ഥിക്കുന്നതിനുമുള്ള ഹാൻഡ്‌ലറുടെ പേര് session.save_handler വ്യക്തമാക്കുന്നു. സ്ഥിരസ്ഥിതി ഫയലുകൾ പ്രകാരം.

സെഷൻ.സേവ്_പാത്ത് ഹാൻഡ്‌ലർ സംഭരിക്കുന്നതിന് കൈമാറുന്ന ആർഗ്യുമെൻ്റ് വ്യക്തമാക്കുന്നു. നിങ്ങൾ ഡിഫോൾട്ട് ഫയൽ ഹാൻഡ്‌ലർ തിരഞ്ഞെടുത്താൽ, ഫയലുകൾ സൃഷ്‌ടിക്കുന്ന സ്ഥലത്തേക്കുള്ള പാത ഇതായിരിക്കും. സ്ഥിരസ്ഥിതി /tmp ആണ്. session.save_path-ൻ്റെ പാതയുടെ ആഴം 2-ൽ കൂടുതലാണെങ്കിൽ, മാലിന്യ ശേഖരണം നടക്കില്ല.

session.name സെഷൻ പേര് വ്യക്തമാക്കുന്നു, അത് കുക്കിയുടെ പേരായി ഉപയോഗിക്കുന്നു. അതിൽ അക്ഷരങ്ങളും അക്കങ്ങളും മാത്രം അടങ്ങിയിരിക്കണം. സ്ഥിരസ്ഥിതി PHPSESSID ആണ്.

ആരംഭ അഭ്യർത്ഥനയിൽ സെഷൻസ് മൊഡ്യൂൾ സെഷൻ സ്വയമേവ ആരംഭിക്കുന്നുണ്ടോ എന്ന് session.auto_start വ്യക്തമാക്കുന്നു. ഡിഫോൾട്ട് 0 ആണ് (അപ്രാപ്തമാക്കി).

session.cookie_lifetime കുക്കി സംഭരണ കാലയളവ് സെക്കൻഡിൽ വ്യക്തമാക്കുന്നു. 0 ൻ്റെ മൂല്യം അർത്ഥമാക്കുന്നത് "ബ്രൗസർ അടയ്ക്കുന്നത് വരെ" എന്നാണ്. സ്ഥിരസ്ഥിതി 0 ആണ്.

session.serialize_handler ഡാറ്റ സീരിയലൈസേഷൻ/ഡീസിയലൈസേഷനായി ഹാൻഡ്‌ലറിൻ്റെ പേര് നിർവചിക്കുന്നു. നിലവിൽ ആന്തരിക PHP (നാമം php), WDDX (നാമം wddx) ഫോർമാറ്റുകൾ പിന്തുണയ്ക്കുന്നു. WDDX പിന്തുണയോടെ PHP കംപൈൽ ചെയ്യുമ്പോൾ മാത്രമേ WDDX ലഭ്യമാകൂ. സ്ഥിരസ്ഥിതിയായി php.

സെഷൻ.ജിസി_പ്രോബബിലിറ്റി ഓരോ അഭ്യർത്ഥനയിലും ജിസി (ഗാർബേജ് കളക്ഷൻ) യൂട്ടിലിറ്റി ആരംഭിക്കുന്നതിനുള്ള ശതമാനം പ്രോബബിലിറ്റി വ്യക്തമാക്കുന്നു. സ്ഥിരസ്ഥിതി 1 ആണ്.

സെഷൻ.gc_maxlifetime ഡാറ്റ "മാലിന്യം" ആയി കണക്കാക്കുകയും മായ്‌ക്കുകയും ചെയ്യുന്ന സെക്കൻഡുകളുടെ എണ്ണം വ്യക്തമാക്കുന്നു.

സെഷൻ.referer_check-ൽ നിങ്ങൾക്ക് എല്ലാ HTTP അഭ്യർത്ഥനകളിലും പരിശോധിക്കാൻ കഴിയുന്ന ഒരു സബ്‌സ്ട്രിംഗ് അടങ്ങിയിരിക്കുന്നു. അഭ്യർത്ഥന അയച്ചത് ഒരു ക്ലയൻ്റ് ആണെങ്കിൽ സബ്‌സ്ട്രിംഗ് കണ്ടെത്തിയില്ലെങ്കിൽ, ഉൾച്ചേർത്ത സെഷൻ ഐഡി അസാധുവായി അടയാളപ്പെടുത്തും. സ്ഥിരസ്ഥിതി ഒരു ശൂന്യമായ സ്ട്രിംഗാണ്.

സെഷൻ.entropy_file ഒരു സെഷൻ ഐഡി സൃഷ്ടിക്കുന്ന പ്രക്രിയയിൽ ഒരു അധിക ഉറവിടമായി ഉപയോഗിക്കുന്ന ഒരു ബാഹ്യ ഉറവിടത്തിലേക്കുള്ള (ഫയൽ) പാത വ്യക്തമാക്കുന്നു. ഉദാഹരണങ്ങൾ: /dev/random അല്ലെങ്കിൽ /dev/urandom, ഇവ പല Unix സിസ്റ്റങ്ങളിലും ലഭ്യമാണ്.

സെഷൻ.entropy_length മുകളിൽ വ്യക്തമാക്കിയ ഫയലിൽ നിന്ന് വായിക്കുന്ന ബൈറ്റുകളുടെ എണ്ണം വ്യക്തമാക്കുന്നു. ഡിഫോൾട്ട് 0 ആണ് (അപ്രാപ്തമാക്കി).

നിങ്ങൾ PHP പഠിക്കുന്നത് തുടരുമ്പോൾ, നിങ്ങൾ സെഷനുകളായി അത്തരമൊരു സവിശേഷത ഉപയോഗിക്കും, അല്ലെങ്കിൽ ഇടയ്ക്കിടെ അതിനെക്കുറിച്ച് കേൾക്കുകയും ചെയ്യും. ഈ ലേഖനത്തിൽ ഞാൻ അവരെക്കുറിച്ച് കൂടുതൽ വിശദമായി സംസാരിക്കുകയും അവയുടെ പ്രവർത്തന തത്വം വിശകലനം ചെയ്യാൻ ചിത്രീകരണ ഉദാഹരണങ്ങൾ ഉപയോഗിക്കുകയും ചെയ്യും. അവ സാധാരണയായി എവിടെ, എങ്ങനെ ഉപയോഗിക്കാമെന്നും ഞാൻ നിങ്ങളോട് പറയും.

എന്താണ് ഒരു സെഷൻ?സെഷൻ ഐഡൻ്റിഫയർ ഉപയോഗിച്ച് സൈറ്റിനും ഉപയോക്താവിനും ഇടയിൽ ഒരു തരത്തിലുള്ള കണക്ഷൻ ഉണ്ടാക്കാൻ സെഷനുകൾ നിങ്ങളെ അനുവദിക്കുന്നു. എല്ലാ സെഷൻ വേരിയബിളുകളും അവയുടെ മൂല്യങ്ങളും സെർവറിൽ മാത്രം സംഭരിച്ചിരിക്കുന്നു. ഉപയോക്താവും സെർവറും സെഷൻ ഐഡൻ്റിഫയറുകൾ മാത്രമേ സംഭരിക്കുന്നുള്ളൂ, അവ ക്രമരഹിതമായി സൃഷ്ടിക്കപ്പെടുന്നു; ഈ സെർവർ-ക്ലയൻ്റ് കണക്ഷൻ സ്ഥാപിക്കാൻ അവർ കൃത്യമായി അനുവദിക്കുന്നു.

ക്ലയൻ്റ് ഭാഗത്ത് (അവൻ്റെ കമ്പ്യൂട്ടറിൽ) സംഭരിച്ചിരിക്കുന്ന സെഷൻ ഐഡി ഒരു ഫയലാണ് കുക്കി. കുക്കികൾ ഉപയോക്താവിൻ്റെ ബ്രൗസറിൽ സംഭരിച്ചിരിക്കുന്നു, എന്നാൽ അനുബന്ധ ഫയലും സെർവറിൽ സൃഷ്ടിക്കപ്പെടുന്നു.

നമുക്ക് നേരെ പരിശീലനത്തിലേക്ക് കടക്കാം.

ഒരു സെഷൻ സൃഷ്ടിക്കുക:

സെഷൻ_സ്റ്റാർട്ട് ഫംഗ്‌ഷൻ ഉപയോഗിക്കുന്നതാണ് ഇവിടെ ഏറ്റവും അടിസ്ഥാന മാർഗം:

1 2	// സെഷൻ ആരംഭിക്കുകസെഷൻ_ആരംഭം();

// സെഷൻ ആരംഭിക്കുക_ആരംഭിക്കുക();

ഒരു സെഷൻ ഐഡൻ്റിഫയർ ഉണ്ടോ എന്ന് ഈ ഫംഗ്ഷൻ പരിശോധിക്കുന്നു; അത് നിലവിലില്ലെങ്കിൽ, അത് സൃഷ്ടിക്കുന്നു. അത് ലഭ്യമാണെങ്കിൽ, അത് നിലവിലുള്ള സെഷനിൽ നിന്ന് രജിസ്റ്റർ ചെയ്ത വേരിയബിളുകൾ ലോഡ് ചെയ്യുന്നു.

ഈ നിർമ്മിതിയെ ഓരോ പേജിലും ഒരു തവണ മാത്രമേ വിളിക്കാവൂ കൂടാതെ ഏതെങ്കിലും ഔട്ട്‌പുട്ടിന് മുമ്പായി (ഈ നിയമം setcookie() യ്ക്കും ബാധകമാണ്).

ഞാൻ നിങ്ങൾക്ക് ഒരു ഉദാഹരണം നൽകാം: ഒരു ബ്രൗസറിൽ ഒരു സെഷൻ സൃഷ്ടിക്കുമ്പോൾ, അവിടെയുള്ള കുക്കി ഇതുപോലെ കാണപ്പെടുന്നു:

ഒരു സെഷൻ സൃഷ്‌ടിക്കുമ്പോൾ, ഇനിപ്പറയുന്ന കുക്കി ബ്രൗസറിലേക്ക് അയയ്‌ക്കും:

1 2	പ്രതിധ്വനി "സെഷൻ്റെ പേര്:". session_name(). "സെഷൻ ഐഡി: ". സെഷൻ ഐഡി(); // സെഷൻ്റെ പേര്: PHPSESSID സെഷൻ ഐഡി: mceu371l97id3sa0vcbjqnht06

echo "സെഷൻ്റെ പേര്: ".session_name(). " സെഷൻ ഐഡി: ".session_id(); // സെഷൻ്റെ പേര്: PHPSESSID സെഷൻ ഐഡി: mceu371l97id3sa0vcbjqnht06

നമുക്ക് ഒരു സെഷൻ വേരിയബിൾ സൃഷ്ടിക്കാം:

$_SESSION അറേയുടെ സൂപ്പർഗ്ലോബൽ ഘടകത്തിലേക്ക് കുറച്ച് മൂല്യം ചേർത്ത് ഒരു സെഷൻ വേരിയബിൾ സൃഷ്ടിക്കാൻ കഴിയും:

അൺസെറ്റ് ($_SESSION["ലോഗിൻ"]);

മുകളിലുള്ള രീതി നല്ലതാണ്, എന്നാൽ നിങ്ങൾക്ക് മുഴുവൻ $_SESSION അറേയും മായ്‌ക്കാൻ കഴിയും, അതുവഴി സെഷനിൽ നിന്ന് എല്ലാ വേരിയബിളുകളും നീക്കം ചെയ്യാം:

1 2	// ഞങ്ങളുടെ $_SESSION അറേ വൃത്തിയാക്കുക$_SESSION = അറേ () ;

// ഞങ്ങളുടെ അറേ മായ്‌ക്കുക $_SESSION $_SESSION = അറേ();

2. ഇപ്പോൾ നമുക്ക് കുക്കിയെ അസാധുവാക്കേണ്ടതുണ്ട് (കുക്കിയിലും URL-ലും സെഷൻ ഐഡി ആക്‌സസ് ചെയ്യുമ്പോൾ സെഷൻ്റെ പേര് പരാമർശിക്കുന്നിടത്ത്):

1 2 3

എങ്കിൽ (ഇസെറ്റ് ($_COOKIE [ session_name () ] ) ) ( // session_name() - നിലവിലെ സെഷൻ്റെ പേര് പുറത്തെടുക്കുക setcookie (session_name () , "" , time () - 86400 , "/" ); )

എങ്കിൽ (isset($_COOKIE)) ( // session_name() - നിലവിലെ സെഷൻ സെറ്റ്‌കുക്കിയുടെ പേര് പുറത്തെടുക്കുക(session_name(), "", time()-86400, "/"); )

3. ശരി, അടുത്തതായി ഞങ്ങൾ സെഷൻ നശിപ്പിക്കും (അത് അടയ്ക്കുക):

സെഷൻ_ആരംഭം(); ob_start();

മുമ്പ് ചർച്ച ചെയ്ത കോഡുകളും ഫംഗ്‌ഷനുകളും ഉപയോഗിച്ച് കൂടുതൽ വിശദമായ കോഡ് ഉദാഹരണം ഇതാ:

1 2 3 4 5 6 7 8 9

എങ്കിൽ (ഇസെറ്റ് ($_SESSION [ "ലോഗിൻ" ] ) ) ( "ഹലോ, " () ] ) ) (setcookie (session_name () , "" , time () - 86400 , "/" ) ; // ഞങ്ങളുടെ സെഷൻ്റെ ഉള്ളടക്കം ഒരു ശൂന്യമായ സ്ട്രിംഗാണ്) ob_end_flush (); // ബ്രൗസറിലേക്ക് ഔട്ട്‌പുട്ട് അയയ്‌ക്കുക session_destroy();

എങ്കിൽ (ഇസെറ്റ്($_SESSION["ലോഗിൻ"])) (എക്കോ "ഹലോ, " . $_SESSION["പേര്"] . " "; സജ്ജമാക്കിയിട്ടില്ല($_SESSION["ലോഗിൻ"]); എങ്കിൽ (ഇസെറ്റ്($_COOKIE)) (setcookie(session_name(), "", time()-86400, "/"); // ഞങ്ങളുടെ സെഷൻ്റെ ഉള്ളടക്കം ഒരു ശൂന്യമായ സ്‌ട്രിംഗ് ആണ് ) ob_end_flush(); // ഔട്ട്‌പുട്ട് ബ്രൗസറിലേക്ക് അയയ്ക്കുക session_destroy();

എന്നിരുന്നാലും, ob_end_flush() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നത് എല്ലായ്പ്പോഴും ആവശ്യമില്ല എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. ചില സ്ക്രിപ്റ്റ് എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ PHP വ്യാഖ്യാതാവ് നിങ്ങളുടെ ബഫർ സ്വയമേവ മായ്‌ക്കുന്നതിനാൽ എല്ലാം.

നമുക്ക് സെഷൻ ഐഡൻ്റിഫയർ പുനഃസൃഷ്ടിക്കാം:

ഓരോ തവണയും നിങ്ങൾ സിസ്റ്റത്തിൽ ലോഗിൻ ചെയ്യുമ്പോൾ, സുരക്ഷാ കാരണങ്ങളാൽ, സെഷൻ ഐഡൻ്റിഫയർ പുനഃസൃഷ്ടിക്കേണ്ടത് ആവശ്യമാണ്. നിങ്ങളുടെ സെഷൻ വേരിയബിളുകളിലെ എല്ലാ വിവരങ്ങളും നിങ്ങളുടെ വെബ് സെർവറിൽ ഒരു നിർദ്ദിഷ്ട ഫയലിൽ പ്ലെയിൻ ടെക്സ്റ്റിൻ്റെ രൂപത്തിൽ സംഭരിച്ചിരിക്കുന്നു, സെഷനിൽ ഉപയോഗിക്കുന്ന വേരിയബിളുകളെക്കുറിച്ചുള്ള എല്ലാ വിവരങ്ങളും സംരക്ഷിക്കപ്പെടുകയും സെഷൻ ഐഡൻ്റിഫയർ മാത്രം മാറുകയും ചെയ്യുന്നു. സെഷൻ ഐഡൻ്റിഫയർ പുനഃസൃഷ്ടിക്കുന്നതിന്, session_regenerate_id() ഫംഗ്ഷൻ ഉപയോഗിക്കുക, തുടർന്ന്, നിലവിലുള്ള പേജ് പുതുക്കുക അല്ലെങ്കിൽ ഒരു റീഡയറക്‌ട് ഉപയോഗിച്ച് ഉപയോക്താവിനെ മറ്റൊരു പേജിലേക്ക് അയയ്ക്കുക.

സെഷനുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നു:

ചുവടെയുള്ള സ്ക്രീൻഷോട്ടിൽ നിങ്ങൾക്ക് സെഷൻ മെക്കാനിസത്തിൻ്റെ ഒരു ചെറിയ അവലോകനം കാണാൻ കഴിയും.

സെഷൻ ആയുസ്സ് കുറയ്ക്കാം:

സ്റ്റാൻഡേർഡ് സെഷൻ ലൈഫ് ടൈം മൂല്യം 0 ആണ്, അതായത്, ഉപയോക്താവ് ബ്രൗസർ വിൻഡോ അടയ്ക്കുകയാണെങ്കിൽ, സെഷനും ക്ലോസ് ചെയ്യും. എന്നാൽ ചില സമയങ്ങളിൽ ഒരു ക്ലയൻ്റ് സെഷൻ നിർബന്ധിതമായി നശിപ്പിക്കേണ്ട ആവശ്യമുണ്ട്, കുറച്ച് സമയം കഴിഞ്ഞതിന് ശേഷം, ഉദാഹരണത്തിന് സൈറ്റിലെ അവൻ്റെ ഭാഗത്തെ നിഷ്ക്രിയത്വം കാരണം. ഉപയോക്തൃ അംഗീകാരത്തിൻ്റെ ഉദാഹരണം ഉപയോഗിച്ച് അത്തരമൊരു നടപ്പാക്കലിൻ്റെ രീതി നോക്കാം: ഞങ്ങൾ ഒരുതരം വേരിയബിൾ സൃഷ്ടിക്കുകയും ഉപയോക്തൃ അംഗീകാര സമയത്ത് ഉപയോഗിക്കുന്ന സമയം അതിൽ സംഭരിക്കുകയും ചെയ്യും, ഉദാഹരണത്തിന്, ഉപയോക്താവ് പേജ് നാവിഗേറ്റ് ചെയ്യാൻ ശ്രമിക്കുകയാണെങ്കിൽ, ഞങ്ങൾ താരതമ്യം ചെയ്യുന്നു അവൻ നിഷ്‌ക്രിയനായിരുന്ന സമയം, ഈ പരിധി കവിഞ്ഞാൽ, അവനെ ലോഗ് ഔട്ട് ചെയ്‌ത് അംഗീകാര പേജിലേക്ക് അയയ്‌ക്കും.

1 2 3 4 5 6 7 8

$_SESSION["ആരംഭിക്കുക"] = സമയം(); // ഉപയോക്താവ് ലോഗിൻ ചെയ്ത സമയത്തിൻ്റെ ആരംഭം$timezon = സമയം (); // ഇത്തവണ (ഇപ്പോൾ ഉള്ളത്)$time_limit = 2000 ; // ഉപയോക്താവ് നിഷ്‌ക്രിയമായിരിക്കുന്ന പരമാവധി സമയമാണിത്എങ്കിൽ ($timezon > $_SESSION [ "start" ] + $time_limit ) (എക്കോ "സമയം കഴിഞ്ഞു"; ) വേറെ ($_SESSION [ "ആരംഭിക്കുക" ] = സമയം () ; ) // എല്ലാം നല്ലതാണെങ്കിൽ, അപ്ഡേറ്റ് ചെയ്യുക

$_SESSION["ആരംഭിക്കുക"] = സമയം(); // ഉപയോക്താവ് ലോഗിൻ ചെയ്ത സമയത്തിൻ്റെ ആരംഭം $timezon= time(); // ഈ സമയം (ഇപ്പോൾ നിലവിലുള്ളത്) $time_limit = 2000; // ($timezon> $_SESSION["start"] + $time_limit) (എക്കോ "സമയം അവസാനിച്ചു"; ) അല്ലെങ്കിൽ ($_SESSION["start"] = time(); ) // എല്ലാം ശരിയാണെങ്കിൽ, നമുക്ക് അപ്ഡേറ്റ് ചെയ്യാം

ചിലപ്പോൾ ആളുകൾക്ക് ഒരു ചോദ്യം ഉണ്ടാകും "അനന്തമായ ഒരു സെഷൻ ജീവിതകാലം എങ്ങനെ നടപ്പിലാക്കാം?", ഇവിടെ ഞാൻ നിങ്ങൾക്ക് ഉത്തരം തരാം. ഇത് ചെയ്യാൻ പാടില്ല, ഇത് ആശയത്തിൽ അടിസ്ഥാനപരമായി തെറ്റാണ്. സൈറ്റ് സന്ദർശിക്കുന്ന ഉപയോക്താവിൻ്റെ ആവശ്യത്തിനായി സെഷൻ സൃഷ്ടിച്ചു - അത് തുറന്നു, അവൻ പോയി - അത് അടച്ചു (നശിപ്പിച്ചു). വീണ്ടും ലോഗിൻ ചെയ്തപ്പോൾ പുതിയൊരു സെഷൻ തുറന്നു. എന്നിരുന്നാലും, സെഷനായി നിങ്ങൾക്ക് കുക്കികളിൽ നിന്നുള്ള ഡാറ്റ ഉപയോഗിക്കാം, അത് വളരെക്കാലം സൂക്ഷിക്കാൻ കഴിയും, ഉദാഹരണത്തിന്, "എന്നെ ഓർക്കുക" ചെക്ക്ബോക്സ് ഉപയോഗിക്കുമ്പോൾ (വെബ്സൈറ്റുകളിലുള്ളവ ഓർക്കുന്നുണ്ടോ?)...

കുക്കികൾ പ്രവർത്തനരഹിതമാക്കിയ സെഷനുകൾ ഉപയോഗിക്കുന്നത്:

ഇത് സംഭവിക്കില്ലെന്ന് എന്നോട് പറയൂ? നിർഭാഗ്യവശാൽ, ഇത് ചിലപ്പോൾ സംഭവിക്കുന്നു. ഉദാഹരണത്തിന്, ഞങ്ങൾ session.use_trans_sid ക്രമീകരണം 1 ആയി സജ്ജീകരിക്കുകയാണെങ്കിൽ, ഒരു കുക്കിയുടെ അഭാവത്തിൽ, നിങ്ങളുടെ അഭ്യർത്ഥന ലൈനിലെ GET രീതി ഉപയോഗിച്ച് PHP PHPSESSID പാരാമീറ്ററുകൾ കൈമാറും.

അത്രയേയുള്ളൂ, ലേഖനം അവസാനിച്ചു. സെഷനുകളുടെ ഉപയോഗത്തെക്കുറിച്ച് നിങ്ങൾക്ക് ഇപ്പോഴും ചോദ്യങ്ങളുണ്ടെങ്കിൽ, അല്ലെങ്കിൽ എന്തെങ്കിലും കൂട്ടിച്ചേർക്കലുകളോ അഭിപ്രായങ്ങളോ ഉണ്ടെങ്കിൽ, ഈ ലേഖനത്തിലെ അഭിപ്രായങ്ങളിൽ നിങ്ങൾക്ക് എല്ലാം നൽകാം.

ഒരു വെബ്‌സൈറ്റിൻ്റെയോ അപ്ലിക്കേഷൻ്റെയോ എല്ലാ പേജുകളിലും ഉപയോക്തൃ ഡാറ്റ സംഭരിക്കാൻ അനുവദിക്കുന്ന പിഎച്ച്പിയിലെ ഒരു പ്രധാന സാങ്കേതികതയാണ് സെഷൻ കൈകാര്യം ചെയ്യൽ. ഈ ലേഖനത്തിൽ നിങ്ങൾ PHP-യിൽ സെഷൻ കൈകാര്യം ചെയ്യുന്നതിനുള്ള അടിസ്ഥാനകാര്യങ്ങൾ പഠിക്കും.

സെഷനുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്നും അവ കുക്കികളുമായി എങ്ങനെ ബന്ധപ്പെട്ടിരിക്കുന്നുവെന്നും വിശദീകരിച്ചുകൊണ്ട് ഞങ്ങൾ ആരംഭിക്കും. സെഷനുകൾ ഉപയോഗിച്ച് എങ്ങനെ പ്രവർത്തിക്കാമെന്ന് കാണിക്കുന്ന കുറച്ച് കോഡ് സ്‌നിപ്പെറ്റുകൾ ഞങ്ങൾ നോക്കും. സെഷനുകൾ എങ്ങനെ സൃഷ്ടിക്കാമെന്നും നശിപ്പിക്കാമെന്നും സെഷൻ വേരിയബിളുകൾ എങ്ങനെ മാറ്റാമെന്നും നിങ്ങൾ പഠിക്കും.

PHP-യിലെ ഒരു സെഷൻ എന്താണ്?

ഒരു സൈറ്റോ ആപ്ലിക്കേഷനോ നാവിഗേറ്റ് ചെയ്യുമ്പോൾ ഉപയോക്താക്കളെ തിരിച്ചറിയുന്നതിനായി വെബ് പേജുകളിലുടനീളം വിവരങ്ങൾ സംഭരിക്കുന്നതിനുള്ള ഒരു സംവിധാനമാണ് സെഷൻ. ഒരു വെബ്‌സൈറ്റിന് സെഷനുകൾ ആവശ്യമായിരിക്കുന്നത് എന്തുകൊണ്ടാണെന്ന് നിങ്ങൾ ആശ്ചര്യപ്പെടുന്നുണ്ടോ? സെഷനുകൾ ആവശ്യമായി വരുന്നത് എന്തുകൊണ്ടാണെന്ന് മനസിലാക്കാൻ, ഞങ്ങൾ കുറച്ച് പിന്നോട്ട് പോയി HTTP പ്രോട്ടോക്കോൾ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് നോക്കേണ്ടതുണ്ട്.

HTTP പ്രോട്ടോക്കോൾ ഒരു സ്‌റ്റേറ്റ്‌ലെസ് പ്രോട്ടോക്കോൾ ആണ്, അതിനർത്ഥം ഒന്നിലധികം അഭ്യർത്ഥനകളിലുടനീളം സെർവറിന് ഒരു നിർദ്ദിഷ്ട ഉപയോക്താവിനെ പൊരുത്തപ്പെടുത്താൻ കഴിയില്ല എന്നാണ്. ഉദാഹരണത്തിന്, ഒരു വെബ് പേജ് ആക്സസ് ചെയ്യുമ്പോൾ, അഭ്യർത്ഥിച്ച പേജിൻ്റെ ഉള്ളടക്കം നൽകുന്നതിന് സെർവറിന് ഉത്തരവാദിത്തമുണ്ട്. അതിനാൽ നിങ്ങൾ ഒരേ വെബ്‌സൈറ്റിൽ മറ്റ് പേജുകൾ ആക്‌സസ് ചെയ്യുമ്പോൾ, വെബ് സെർവർ ഓരോ അഭ്യർത്ഥനയും പരസ്പരം ബന്ധമില്ലാത്തതുപോലെ വെവ്വേറെ വ്യാഖ്യാനിക്കുന്നു. ഓരോ അഭ്യർത്ഥനയും ഒരേ ഉപയോക്താവിൽ നിന്നാണ് വരുന്നതെന്ന് സെർവറിന് അറിയില്ല.

ഇനിപ്പറയുന്ന ഡയഗ്രം HTTP പ്രോട്ടോക്കോൾ ഹ്രസ്വമായി ചിത്രീകരിക്കുന്നു.

ഈ മോഡലിൽ, നിങ്ങൾക്ക് ഉപയോക്തൃ വിവരങ്ങൾ പ്രദർശിപ്പിക്കണമെങ്കിൽ, ഓരോ അഭ്യർത്ഥനയിലും നിങ്ങൾ ഉപയോക്താവിനെ പ്രാമാണീകരിക്കേണ്ടതുണ്ട്. നിങ്ങളുടെ ഡാറ്റയുടെ എല്ലാ പേജിലും നിങ്ങളുടെ ഉപയോക്തൃനാമവും പാസ്‌വേഡും നൽകേണ്ടതുണ്ടെങ്കിൽ സങ്കൽപ്പിക്കുക! അതെ, ഇത് ബുദ്ധിമുട്ടുള്ളതും പൊതുവെ പ്രായോഗികവുമല്ല, ഇവിടെയാണ് സെഷനുകൾ രക്ഷാപ്രവർത്തനത്തിലേക്ക് വരുന്നത്.

ഒരേ സൈറ്റിൻ്റെയോ ആപ്ലിക്കേഷൻ്റെയോ വ്യത്യസ്ത പേജുകൾക്കിടയിൽ വിവരങ്ങൾ കൈമാറാൻ ഒരു സെഷൻ നിങ്ങളെ അനുവദിക്കുന്നു, ഒപ്പം നില നിലനിർത്താൻ സഹായിക്കുന്നു. എല്ലാ അഭ്യർത്ഥനകളും ഒരേ ഉപയോക്താവിൽ നിന്നാണെന്ന് അറിയാൻ ഇത് സെർവറിനെ അനുവദിക്കുന്നു, ഇത് ഉപയോക്താവിൻ്റെ വിവരങ്ങളും മുൻഗണനകളും പ്രദർശിപ്പിക്കാൻ സൈറ്റിനെ അനുവദിക്കുന്നു.

സെഷനുകളും കുക്കികളും ഉപയോഗിച്ച് ലോഗിൻ കൈകാര്യം ചെയ്യുന്നു

തിരശ്ശീലയ്ക്ക് പിന്നിൽ എന്താണ് സംഭവിക്കുന്നതെന്ന് മനസിലാക്കാൻ നമുക്ക് ഒരു സാധാരണ വെബ്സൈറ്റ് ലോഗിൻ ഉദാഹരണം നോക്കാം.

ഉപയോക്താവ് വെബ്‌സൈറ്റ് ലോഗിൻ പേജ് തുറക്കുന്നു.
ലോഗിൻ ഫോം സമർപ്പിച്ച ശേഷം, മറ്റേ അറ്റത്തുള്ള സെർവർ നൽകിയ ക്രെഡൻഷ്യലുകൾ പരിശോധിച്ച് അഭ്യർത്ഥന പ്രാമാണീകരിക്കുന്നു.
ഉപയോക്താവ് നൽകിയ ക്രെഡൻഷ്യലുകൾ ശരിയാണെങ്കിൽ, സെർവർ ഒരു പുതിയ സെഷൻ സൃഷ്ടിക്കുന്നു. സെർവർ ഒരു സെഷൻ ഐഡി എന്ന് വിളിക്കുന്ന ഒരു അദ്വിതീയ റാൻഡം നമ്പർ സൃഷ്ടിക്കുന്നു. കൂടാതെ, സെർവറിൽ ഒരു പുതിയ ഫയൽ സൃഷ്ടിക്കപ്പെടുന്നു, അത് സെഷനുമായി ബന്ധപ്പെട്ട വിവരങ്ങൾ സംഭരിക്കുന്നതിന് ഉപയോഗിക്കുന്നു.
തുടർന്ന്, സെഷൻ ഐഡി ഉപയോക്താവിന് അവൻ അഭ്യർത്ഥിച്ചതെന്തും സഹിതം തിരികെ നൽകും. തിരശ്ശീലയ്ക്ക് പിന്നിൽ, ഈ സെഷൻ ഐഡി PHPSESSID കുക്കി പ്രതികരണ തലക്കെട്ടിൽ അയയ്‌ക്കുന്നു (അതിനെയാണ് ഡിഫോൾട്ടായി വിളിക്കുന്നത്).
സെർവറിൽ നിന്ന് ബ്രൗസറിന് ഒരു പ്രതികരണം ലഭിക്കുമ്പോൾ, അതിന് ഒരു PHPSESSID കുക്കി ഹെഡർ ലഭിക്കും. നിങ്ങളുടെ ബ്രൗസർ കുക്കികളെ അനുവദിക്കുകയാണെങ്കിൽ, അത് സെർവർ അയച്ച സെഷൻ ഐഡി സംഭരിക്കുന്ന ഈ PHPSESSID സംഭരിക്കും.
തുടർന്നുള്ള അഭ്യർത്ഥനകൾക്കായി, PHPSESSID കുക്കി വീണ്ടും സെർവറിലേക്ക് കൈമാറുന്നു. സെർവറിന് PHPSESSID കുക്കി ലഭിക്കുമ്പോൾ, ആ സെഷൻ ഐഡി ഉപയോഗിച്ച് ഒരു സെഷൻ ആരംഭിക്കാൻ അത് ശ്രമിക്കുന്നു. സെഷൻ ഇനീഷ്യലൈസേഷൻ സമയത്ത് നേരത്തെ സൃഷ്ടിച്ച സെഷൻ ഫയൽ ലോഡ് ചെയ്തുകൊണ്ടാണ് ഇത് ചെയ്യുന്നത്. അത് സെഷൻ ഫയലിൽ സംഭരിച്ചിരിക്കുന്ന ഡാറ്റ ഉപയോഗിച്ച് $_SESSION എന്ന സൂപ്പർഗ്ലോബൽ അറേ വേരിയബിളിനെ സമാരംഭിക്കുന്നു.

ഈ രീതിയിൽ, ഒന്നിലധികം അഭ്യർത്ഥനകളിൽ പോലും ഉപയോക്തൃ ഡാറ്റ സംരക്ഷിക്കപ്പെടുന്നു, കൂടാതെ മുഴുവൻ സെഷനിലും ഉപയോക്താവിന് നഷ്ടമാകില്ല.

സെഷനുകളിൽ HTTP പ്രോട്ടോക്കോൾ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് ഇനിപ്പറയുന്ന ഡയഗ്രം കാണിക്കുന്നു.

സെഷനുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിനെക്കുറിച്ചുള്ള ഒരു ഹ്രസ്വ ആമുഖം നിങ്ങൾ ഇപ്പോൾ കണ്ടുകഴിഞ്ഞു, സെഷൻ വേരിയബിളുകൾ എങ്ങനെ സൃഷ്ടിക്കാമെന്നും കൈകാര്യം ചെയ്യാമെന്നും കാണിക്കുന്നതിന് ഞങ്ങൾ ചില പ്രായോഗിക ഉദാഹരണങ്ങൾ സൃഷ്ടിക്കും.

ഒരു സെഷൻ എങ്ങനെ ആരംഭിക്കാം

ഈ വിഭാഗത്തിൽ, പിഎച്ച്‌പിയിൽ ഒരു സെഷൻ എങ്ങനെ ആരംഭിക്കാമെന്ന് ഞങ്ങൾ ചർച്ച ചെയ്യും.

സെഷൻ വേരിയബിളുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുമ്പോഴെല്ലാം, സെഷൻ ഇതിനകം തന്നെ പ്രവർത്തിക്കുന്നുവെന്ന് ഉറപ്പാക്കേണ്ടതുണ്ട്. PHP-യിലെ ഒരു സെഷൻ പല തരത്തിൽ ആരംഭിക്കാവുന്നതാണ്.

സെഷൻ_സ്റ്റാർട്ട് ഫംഗ്‌ഷൻ ഉപയോഗിക്കുന്നു

സെഷൻ_സ്റ്റാർട്ട് ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് സെഷൻ ആരംഭിക്കുന്ന രീതി നിങ്ങൾ പലപ്പോഴും കാണുന്ന ഒന്നാണ്.

ബ്രൗസറിലേക്ക് എന്തെങ്കിലും അയയ്‌ക്കുന്നതിന് മുമ്പ്, സ്‌ക്രിപ്‌റ്റിൻ്റെ തുടക്കത്തിൽ സെഷൻ_സ്റ്റാർട്ട് ഫംഗ്‌ഷൻ വിളിക്കുന്നത് പ്രധാനമാണ്. അല്ലെങ്കിൽ, കുപ്രസിദ്ധമായ തലക്കെട്ടുകൾ ഇതിനകം അയച്ച പിശക് നിങ്ങൾക്ക് നേരിടേണ്ടിവരും.

യാന്ത്രിക സെഷൻ ആരംഭം

നിങ്ങളുടെ ആപ്ലിക്കേഷനിൽ സെഷനുകൾ ഉപയോഗിക്കണമെങ്കിൽ, session_start ഫംഗ്‌ഷൻ ഉപയോഗിക്കാതെ തന്നെ ഒരു സെഷൻ സ്വയമേവ ആരംഭിക്കാൻ സാധിക്കും.

ഫയലിൽ php.iniഓരോ അഭ്യർത്ഥനയ്ക്കും സ്വയം ഒരു സെഷൻ ആരംഭിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു പാരാമീറ്റർ സെഷൻ.auto_start ഉണ്ട്. ഡിഫോൾട്ട് മൂല്യം 0 (ഓഫ്) ആണ്, ഓട്ടോ സ്റ്റാർട്ട് ഫീച്ചർ പ്രവർത്തനക്ഷമമാക്കാൻ നിങ്ങൾക്കത് 1 (ഓൺ) ആയി സജ്ജീകരിക്കാം.

Session.auto_start = 1

മറുവശത്ത്, നിങ്ങൾക്ക് ഫയലിലേക്ക് ആക്സസ് ഇല്ലെങ്കിൽ php.iniനിങ്ങൾ അപ്പാച്ചെ വെബ് സെർവർ ആണ് ഉപയോഗിക്കുന്നത്, ഈ വേരിയബിൾ ഫയൽ ഉപയോഗിച്ച് സജ്ജമാക്കാൻ കഴിയും .htaccess.

Php_value session.auto_start 1

മുകളിലെ വരി നിങ്ങളിലേക്ക് ചേർത്താൽ .htaccessഫയൽ, തുടർന്ന് ഇത് നിങ്ങളുടെ PHP ആപ്ലിക്കേഷനിൽ സെഷനുകൾ സ്വയമേവ സമാരംഭിക്കും.

സെഷൻ ഐഡി എങ്ങനെ ലഭിക്കും

നമ്മൾ നേരത്തെ ചർച്ച ചെയ്തതുപോലെ, ഓരോ പുതിയ സെഷനും സെർവർ ഒരു അദ്വിതീയ നമ്പർ സൃഷ്ടിക്കുന്നു. നിങ്ങൾക്ക് സെഷൻ ഐഡി ലഭിക്കണമെങ്കിൽ, ഇനിപ്പറയുന്ന സ്‌നിപ്പറ്റിൽ കാണിച്ചിരിക്കുന്നതുപോലെ സെഷൻ_ഐഡി ഫംഗ്‌ഷൻ ഉപയോഗിക്കാം.

ഇത് നിങ്ങൾക്ക് നിലവിലെ സെഷൻ ഐഡി നൽകും. സെഷൻ_ഐഡി ഐഡൻ്റിഫയർ ഫംഗ്ഷൻ രസകരമാണ്, കാരണം ഇതിന് ഒരു ആർഗ്യുമെൻ്റ് എടുക്കാം - സെഷൻ ഐഡൻ്റിഫയർ. സിസ്റ്റം ജനറേറ്റ് ചെയ്‌ത സെഷൻ ഐഡി നിങ്ങളുടേത് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, സെഷൻ_ഐഡി ഫംഗ്‌ഷനിലേക്ക് ആദ്യ ആർഗ്യുമെൻ്റ് പാസാക്കുന്നതിലൂടെ നിങ്ങൾക്കത് ചെയ്യാൻ കഴിയും.

നിങ്ങളുടെ സെഷൻ ഐഡി ഉപയോഗിച്ച് ഒരു സെഷൻ ആരംഭിക്കണമെങ്കിൽ, സെഷൻ_സ്റ്റാർട്ട് കോളിന് മുമ്പായി സെഷൻ_ഐഡി ഫംഗ്‌ഷൻ വന്നിരിക്കണം എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്.

സെഷൻ വേരിയബിളുകൾ സൃഷ്ടിക്കുന്നു

ഈ വിഭാഗത്തിൽ, പിഎച്ച്‌പിയിൽ സെഷൻ വേരിയബിളുകൾ എങ്ങനെ ആരംഭിക്കാമെന്ന് നമ്മൾ പഠിക്കും.

നമ്മൾ ഇതിനകം ചർച്ച ചെയ്തതുപോലെ, ഒരു സെഷൻ ആരംഭിക്കുമ്പോൾ, $_SESSION സൂപ്പർഗ്ലോബൽ അറേ അനുബന്ധ സെഷൻ വിവരങ്ങളോടൊപ്പം ആരംഭിക്കുന്നു. സ്ഥിരസ്ഥിതിയായി, ഇത് ഒരു ശൂന്യമായ അറേ ആയി ആരംഭിക്കുന്നു, കൂടാതെ ഒരു കീ-വാല്യൂ ജോഡി ഉപയോഗിച്ച് നിങ്ങൾക്ക് കൂടുതൽ വിവരങ്ങൾ സംഭരിക്കാൻ കഴിയും.

സെഷൻ വേരിയബിളുകൾ എങ്ങനെ ആരംഭിക്കാമെന്ന് കാണിക്കുന്ന ഇനിപ്പറയുന്ന കോഡ് ഉദാഹരണം നോക്കാം.

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഞങ്ങൾ സെഷൻ_സ്റ്റാർട്ട് ഫംഗ്ഷൻ ഉപയോഗിച്ച് സ്ക്രിപ്റ്റിൻ്റെ തുടക്കത്തിൽ സെഷൻ ആരംഭിച്ചു. ഇതിനുശേഷം, ഞങ്ങൾ നിരവധി സെഷൻ വേരിയബിളുകൾ ആരംഭിച്ചു. അവസാനമായി, $_SESSION സൂപ്പർഗ്ലോബൽ വേരിയബിളിലൂടെ ഞങ്ങൾ ഈ വേരിയബിളുകൾ ഉപയോഗിച്ചു.

$_SESSION ഉപയോഗിച്ച് സെഷൻ ഡാറ്റ സംഭരിക്കുമ്പോൾ, സെഷൻ ആരംഭിച്ചപ്പോൾ സൃഷ്ടിച്ച സെർവറിലെ അനുബന്ധ സെഷൻ ഫയലിൽ അത് സംഭരിക്കപ്പെടും. ഈ രീതിയിൽ, സെഷൻ ഡാറ്റ ഒന്നിലധികം അഭ്യർത്ഥനകൾക്കിടയിൽ പങ്കിടുന്നു.

ഞങ്ങൾ ഇതിനകം കണ്ടതുപോലെ, സെഷൻ വിവരങ്ങൾ അഭ്യർത്ഥനകൾക്കൊപ്പം കൈമാറുന്നു, അതിനാൽ ഒരു പേജിൽ ആരംഭിച്ച സെഷൻ വേരിയബിളുകൾ മറ്റ് പേജുകളിൽ ആക്സസ് ചെയ്യാൻ കഴിയും, കൂടാതെ സെഷൻ്റെ അവസാനം വരെ. ചട്ടം പോലെ, ബ്രൗസർ അടയ്ക്കുമ്പോൾ സെഷനുകൾ കാലഹരണപ്പെടും.

സെഷൻ വേരിയബിളുകൾ എങ്ങനെ മാറ്റാം, ഇല്ലാതാക്കാം

സാധാരണ PHP വേരിയബിളുകൾ പോലെ നിങ്ങളുടെ ആപ്ലിക്കേഷനിൽ മുമ്പ് സൃഷ്‌ടിച്ച സെഷൻ വേരിയബിളുകൾ നിങ്ങൾക്ക് പരിഷ്‌ക്കരിക്കാനോ ഇല്ലാതാക്കാനോ കഴിയും.

സെഷൻ വേരിയബിളുകൾ എങ്ങനെ മാറ്റാമെന്ന് നോക്കാം.

മുകളിലെ കോഡിൽ, $_SESSION["count"] വേരിയബിൾ സജ്ജീകരിച്ചിട്ടുണ്ടോ എന്ന് ഞങ്ങൾ പരിശോധിക്കുന്നു. സജ്ജീകരിച്ചിട്ടില്ലെങ്കിൽ, ഞങ്ങൾ അത് 1 ആയി സജ്ജീകരിക്കും, അല്ലാത്തപക്ഷം ഞങ്ങൾ അത് 1 ആയി വർദ്ധിപ്പിക്കും. അതിനാൽ നിങ്ങൾ ഈ പേജ് നിരവധി തവണ പുതുക്കിയാൽ, ഓരോ തവണയും കൌണ്ടർ ഒന്നായി വർദ്ധിക്കുന്നത് നിങ്ങൾ കാണും!

മറുവശത്ത്, നിങ്ങൾക്ക് ഒരു സെഷൻ വേരിയബിൾ നീക്കം ചെയ്യണമെങ്കിൽ, ഇനിപ്പറയുന്ന സ്‌നിപ്പറ്റിൽ കാണിച്ചിരിക്കുന്നതുപോലെ നിങ്ങൾക്ക് അൺസെറ്റ് ഫംഗ്‌ഷൻ ഉപയോഗിക്കാം.

അതിനാൽ നിങ്ങൾക്ക് $_SESSION["logged_in_user_id"] വേരിയബിൾ ആക്‌സസ് ചെയ്യാൻ കഴിയില്ല, കാരണം അത് സജ്ജീകരിക്കാത്ത ഫംഗ്‌ഷൻ നീക്കം ചെയ്‌തു. ഇങ്ങനെയാണ് നിങ്ങൾക്ക് സെഷൻ വിവരങ്ങൾ മാറ്റാൻ കഴിയുക.

ഒരു സെഷൻ എങ്ങനെ നശിപ്പിക്കാം

ഈ വിഭാഗത്തിൽ, ഒരു സെഷൻ എങ്ങനെ നശിപ്പിക്കാമെന്ന് നമുക്ക് നോക്കാം. മുമ്പത്തെ വിഭാഗത്തിൽ, ചില സെഷൻ വേരിയബിളുകൾ നീക്കം ചെയ്യാൻ ഉപയോഗിക്കുന്ന അൺസെറ്റ് ഫംഗ്‌ഷൻ ഞങ്ങൾ നോക്കി. മറുവശത്ത്, ഒരു സെഷനുമായി ബന്ധപ്പെട്ട എല്ലാ ഡാറ്റയും ഒരേസമയം ഇല്ലാതാക്കണമെങ്കിൽ, നിങ്ങൾക്ക് session_destroy ഫംഗ്‌ഷൻ ഉപയോഗിക്കാം.

ഇനിപ്പറയുന്ന ഉദാഹരണത്തിൽ ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് മനസിലാക്കാൻ ശ്രമിക്കാം.

സെഷൻ_ഡെസ്ട്രോയ് ഫംഗ്ഷൻ നിലവിലെ സെഷനിൽ സംഭരിച്ചിരിക്കുന്നതെല്ലാം ഇല്ലാതാക്കുന്നു. അതിനാൽ, തുടർന്നുള്ള അഭ്യർത്ഥനകൾക്കൊപ്പം നിങ്ങൾ ഒരു ശൂന്യമായ $_SESSION വേരിയബിൾ കാണും, കാരണം ഡിസ്കിൽ സംഭരിച്ചിരിക്കുന്ന സെഷൻ ഡാറ്റ സെഷൻ_ഡെസ്ട്രോയ് ഫംഗ്ഷൻ ഇല്ലാതാക്കി.

സാധാരണഗതിയിൽ, ഉപയോക്താവ് ലോഗ് ഔട്ട് ചെയ്യുമ്പോൾ സെഷൻ_ഡെസ്ട്രോയ് ഫംഗ്ഷൻ ഉപയോഗിക്കണം.

ഉപസംഹാരം

ഈ ലേഖനത്തിൽ, PHP-യിൽ സെഷൻ കൈകാര്യം ചെയ്യുന്നതിനുള്ള അടിസ്ഥാനകാര്യങ്ങൾ ഞങ്ങൾ പഠിച്ചു. വെബ് പേജുകൾക്കായി വിവരങ്ങൾ സംരക്ഷിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു പ്രധാന ആശയമാണിത്.

ലേഖനത്തിൻ്റെ ആദ്യ പകുതിയിൽ, സെഷനുകളുടെ അടിസ്ഥാന ആശയങ്ങൾ ഞങ്ങൾ ചർച്ച ചെയ്തു, തുടർന്ന് സെഷനുകൾ എങ്ങനെ സൃഷ്ടിക്കാമെന്നും നശിപ്പിക്കാമെന്നും സെഷൻ വേരിയബിളുകൾ കൈകാര്യം ചെയ്യാമെന്നും കാണിക്കാൻ ഞങ്ങൾ പിഎച്ച്പിയിൽ ചില ഉദാഹരണങ്ങൾ സൃഷ്ടിച്ചു.

സെഷനുകൾഓരോ ഉപയോക്താവിനും സവിശേഷമായ, സെർവറിൽ ചില ഡാറ്റ സംഭരിക്കുന്നതിന് നിങ്ങളെ അനുവദിക്കുന്ന ഒരു സംവിധാനമാണ്. പ്രത്യേകിച്ചും ശ്രദ്ധയുള്ള വായനക്കാർ ഇതുമായി സാമ്യം കാണും കുക്കി. കൂടാതെ, പൊതുവേ, ഇത് ഒന്നുതന്നെയാണ്. എന്നിരുന്നാലും, പ്രധാന പോയിൻ്റ്: ഡാറ്റ സംഭരിക്കുന്നത് ഉപയോക്താവിൻ്റെ ബ്രൗസറിലല്ല, മറിച്ച് സെർവറിലെ ഒരു പ്രത്യേക ഫയലിലാണ്, ഓരോ ഉപയോക്താവിനും അദ്വിതീയമായ പേര്. ഒരു അതുല്യമായ PHP സെഷൻ ഐഡിഇതിനകം സംഭരിച്ചിരിക്കുന്നു കുക്കി.

നിൻ്റെ കൂടെ പോകാം PHP-യിലെ സെഷനുകൾക്കൊപ്പം പ്രവർത്തിക്കാം. പിന്നെ നമുക്ക് തുടങ്ങാം സെഷൻ_സ്റ്റാർട്ട്() പ്രവർത്തനങ്ങൾ. ഈ ഫംഗ്‌ഷൻ ഇനിപ്പറയുന്നവ ചെയ്യുന്നു: ഉപയോക്താവ് ആദ്യമായി ലോഗിൻ ചെയ്യുകയാണെങ്കിൽ, അത് ഒരു അദ്വിതീയ ഐഡൻ്റിഫയർ സൃഷ്‌ടിച്ച് അത് എഴുതുന്നു കുക്കി, കൂടാതെ ഒരു പുതിയ ഫയൽ സൃഷ്ടിക്കുന്നു, വീണ്ടും ഉപയോക്താവിന് മാത്രമായി. ഉപയോക്താവ് ഇതിനകം ലോഗിൻ ചെയ്‌തിട്ടുണ്ടെങ്കിൽ, സെർവർ അദ്വിതീയ ഐഡൻ്റിഫയറിൻ്റെ മൂല്യം വായിക്കുന്നു കുക്കികൂടാതെ, അതിന് അനുസൃതമായി, ആവശ്യമുള്ള സെഷൻ ഫയൽ ആക്സസ് ചെയ്യുന്നു. ഈ ഫയലിൽ നിന്ന് PHPഎല്ലാ ഡാറ്റയും വായിച്ച് ഒരു അറേയിൽ ഇടുന്നു $_SESSION. സെഷനിലേക്ക് ഒരു വേരിയബിൾ എഴുതുന്ന ഒരു ലളിതമായ കോഡ് എഴുതാം, അല്ലെങ്കിൽ അത് ഇതിനകം എഴുതിയിട്ടുണ്ടെങ്കിൽ അത് വായിക്കുക.

സെഷൻ_ആരംഭം();
എങ്കിൽ (isset($_SESSION["name"])) $name = $_SESSION["name"];
വേറെ $_SESSION["name"] = "15St";
പ്രതിധ്വനി $നാമം;
?>

ആദ്യം ഞങ്ങൾ വിളിക്കുന്നു സെഷൻ_സ്റ്റാർട്ട്() ഫംഗ്‌ഷൻഞാൻ മുകളിൽ വിവരിച്ചത്. തുടർന്ന് വേരിയബിൾ "നിലവിലുണ്ടോ" എന്ന് ഞങ്ങൾ പരിശോധിക്കുന്നു പേര്" സെഷനിൽ. അത് നിലവിലുണ്ടെങ്കിൽ, ഞങ്ങൾ അതിൽ നിന്നുള്ള ഡാറ്റ വായിക്കുകയും ഒരു വേരിയബിളിലേക്ക് എഴുതുകയും ചെയ്യുന്നു പേര്. അത് നിലവിലില്ലെങ്കിൽ (അതായത്, ഉപയോക്താവ് ആദ്യമായി വന്നു), തുടർന്ന് വേരിയബിൾ സജ്ജമാക്കുക " പേര്"സെഷൻ മൂല്യത്തിൽ" 15 സെൻ്റ്.". അടുത്ത വരി വേരിയബിളിൻ്റെ മൂല്യം കാണിക്കുന്നു $പേര്. വ്യക്തമായും, നിങ്ങൾ ആദ്യമായി ഇത് പ്രവർത്തിപ്പിക്കുമ്പോൾ, നിങ്ങൾ ഒരു ശൂന്യമായ വരി കാണും, എന്നാൽ നിങ്ങൾ അത് പ്രവർത്തിപ്പിക്കുമ്പോൾ, നിങ്ങൾ ലൈൻ കാണും " 15 സെൻ്റ്.", സെഷനിൽ നിന്ന് വായിക്കുക.

ഇപ്പോൾ വിലാസ ബാറിൽ പ്രവേശിക്കാൻ ഞാൻ നിങ്ങളെ ഉപദേശിക്കുന്നു: " javascript:document.cookie" (നിങ്ങൾ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിച്ച അതേ ടാബിൽ നൽകുക) ഫലമായി, ഇതുപോലൊന്ന് നിങ്ങൾ കാണും: " PHPSESSID=". അർത്ഥം മാത്രം PHPSESSIDഅങ്ങനെ ഒരു അദ്വിതീയ ഐഡൻ്റിഫയർ ആണ്.

എല്ലാം പൂർണ്ണമായും വ്യക്തമാക്കുന്നതിന്, കണ്ടെത്താൻ പോലും ഞാൻ നിങ്ങളെ ഉപദേശിക്കുന്നു സെഷൻ ഫയൽ. നിങ്ങൾ ഉപയോഗിക്കുന്നുണ്ടെങ്കിൽ ഡെൻവർ, അപ്പോൾ അത് ഫോൾഡറിലാണ് " tmp". " എന്ന് തുടങ്ങുന്ന ഫയലുകൾ നോക്കുക സെസ്സ്_"- ഇവ തന്നെയാണ് സെഷൻ ഫയലുകൾ. നിങ്ങൾക്ക് അവ ഒരു ലളിതമായ നോട്ട്പാഡിൽ തുറക്കാൻ കഴിയും.

വളരെ പ്രധാനപ്പെട്ട മറ്റൊരു സ്വത്താണ് PHP-യിലെ സെഷനുകളുടെ താൽക്കാലികത. എങ്കിൽ എങ്കിൽ കുക്കിഅവ ബ്രൗസർ ഇല്ലാതാക്കുന്നത് വരെ സൂക്ഷിക്കുന്നു. ബ്രൗസർ ഒരിക്കലും ഡിഫോൾട്ടായി അവ ഇല്ലാതാക്കില്ല. തുടർന്ന് സെഷനുകൾ വ്യക്തമാക്കിയ സമയത്തേക്ക് സംഭരിക്കും PHP ക്രമീകരണങ്ങൾ. സ്ഥിരസ്ഥിതിയായി, ഇതാണ് 15 മിനിറ്റ്. അതായത്, നിങ്ങൾ ഉപയോഗിക്കുകയാണെങ്കിൽ സെഷൻ അടിസ്ഥാനമാക്കിയുള്ള പ്രാമാണീകരണം 15 മിനിറ്റിനു ശേഷം നിഷ്ക്രിയത്വംഉപയോക്താവ്, അവൻ വീണ്ടും ലോഗിൻ ചെയ്യേണ്ടിവരും. തീർച്ചയായും, ഇത് നല്ലതാണ്, കാരണം ഉപയോക്താവ് മറന്നാൽ " പുറത്തുപോകുക", അപ്പോൾ മോശമായ ഒന്നും സംഭവിക്കില്ല. ഒരു ആക്രമണകാരിക്ക് ഉപയോക്തൃ അക്കൗണ്ട് ഉപയോഗിക്കാൻ കഴിയില്ല. മാത്രമല്ല, എങ്കിൽ കുക്കികളുടെ ഉപയോഗംഅവ മോഷ്ടിക്കപ്പെടാം, നിങ്ങളുടെ ബ്രൗസറിൽ പകരം വയ്ക്കാം, തൽഫലമായി, ആക്രമണകാരിക്ക് പാസ്‌വേഡ് പോലും അറിയാതെ മറ്റൊരാളുടെ ഡാറ്റ ഉപയോഗിച്ച് അധികാരം ലഭിക്കും. എന്നാൽ ഒരു സെഷൻ മോഷ്ടിക്കാൻ കഴിയില്ല, കാരണം എല്ലാ പാരാമീറ്ററുകളും സെർവറിൽ സംഭരിച്ചിരിക്കുന്നതിനാൽ അവയെക്കുറിച്ച് കണ്ടെത്താൻ ഒരു മാർഗവുമില്ല.

അതിനാൽ, പ്രധാനമായും നിങ്ങളുടെ പരിശീലനത്തിൽ ശ്രമിക്കുക സെഷനുകൾ ഉപയോഗിക്കുക, ശുദ്ധമല്ല കുക്കി.

അവസാനമായി, വളരെ സാധാരണമായ ഒരു തെറ്റിനെക്കുറിച്ച് നിങ്ങൾക്ക് മുന്നറിയിപ്പ് നൽകാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. മുമ്പ് ബ്രൗസറുകളിലേക്ക് ഡാറ്റ ഔട്ട്പുട്ട് ചെയ്യരുത് സെഷൻ_സ്റ്റാർട്ട്() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു, അല്ലെങ്കിൽ അത് ഒരു പിശക് എറിയുന്നു. അതായത്, നിങ്ങൾക്ക് ഇങ്ങനെ എഴുതാൻ കഴിയില്ല:

പ്രതിധ്വനി "ഹലോ";
സെഷൻ_ആരംഭം();
?>

ഈ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുമ്പോൾ ഒരു പിശക് സംഭവിക്കും. അതേ നിയമം പ്രയോഗിച്ചു കുക്കി (setcookie() ഫംഗ്‌ഷൻ). അതിനാൽ, ഇവിടെ എല്ലാം വ്യക്തമാണെന്ന് ഞാൻ കരുതുന്നു.

വേണ്ടി PHP-യിലെ സെഷനുകൾ, തീർച്ചയായും, സ്ഥിതിവിവരക്കണക്കുകൾ, പ്രാമാണീകരണം, വ്യക്തിഗത ഉപയോക്തൃ ക്രമീകരണങ്ങൾ, മറ്റ് സമാന കാര്യങ്ങൾ എന്നിവ സംഭരിക്കുന്നതിന് അവ ഉപയോഗിക്കാനാകും.

പ്രിയ സമൂഹമേ, ആശംസകൾ.

ഒന്നാമതായി, വളരെ ഉപയോഗപ്രദമായ ഒരു വിഭവത്തിന് നന്ദി പറയാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. ഒന്നിലധികം തവണ ഞാൻ ഇവിടെ രസകരമായ നിരവധി ആശയങ്ങളും പ്രായോഗിക ഉപദേശങ്ങളും കണ്ടെത്തി.

ഈ ലേഖനത്തിൻ്റെ ഉദ്ദേശം PHP-യിൽ സെഷനുകൾ ഉപയോഗിക്കുന്നതിൻ്റെ കുഴപ്പങ്ങൾ എടുത്തുകാണിക്കുക എന്നതാണ്. തീർച്ചയായും, PHP ഡോക്യുമെൻ്റേഷനും ധാരാളം ഉദാഹരണങ്ങളും ഉണ്ട്, ഈ ലേഖനം ഒരു സമ്പൂർണ്ണ ഗൈഡ് ആകാൻ ഉദ്ദേശിച്ചുള്ളതല്ല. സെഷനുകളിൽ പ്രവർത്തിക്കുന്നതിൻ്റെ ചില സൂക്ഷ്മതകൾ വെളിപ്പെടുത്തുന്നതിനും അനാവശ്യമായ സമയം പാഴാക്കുന്നതിൽ നിന്ന് ഡവലപ്പർമാരെ സംരക്ഷിക്കുന്നതിനുമാണ് ഇത് രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്.

സെഷനുകൾ ഉപയോഗിക്കുന്നതിനുള്ള ഏറ്റവും സാധാരണമായ ഉദാഹരണം തീർച്ചയായും ഉപയോക്തൃ അംഗീകാരമാണ്. പുതിയ ജോലികൾ ഉണ്ടാകുമ്പോൾ അത് ക്രമേണ വികസിപ്പിക്കുന്നതിന് ഏറ്റവും അടിസ്ഥാനപരമായ നിർവ്വഹണത്തിൽ നിന്ന് നമുക്ക് ആരംഭിക്കാം.

(സ്ഥലവും സമയവും ലാഭിക്കുന്നതിനായി, മനോഹരമായ ക്ലാസ് ശ്രേണി, സമഗ്രമായ പിശക് കൈകാര്യം ചെയ്യൽ, മറ്റ് നല്ല കാര്യങ്ങൾ എന്നിവയുള്ള ഒരു പൂർണ്ണമായ ടെസ്റ്റ് ആപ്ലിക്കേഷൻ ഇവിടെ നിർമ്മിക്കുന്നതിനുപകരം, സെഷൻ ഫംഗ്‌ഷനുകളിൽ മാത്രമായി ഞങ്ങൾ ഞങ്ങളുടെ ഉദാഹരണങ്ങൾ പരിമിതപ്പെടുത്തും).

ഫംഗ്ഷൻ startSession() ( // സെഷൻ ഇതിനകം ആരംഭിച്ചിട്ടുണ്ടെങ്കിൽ, എക്സിക്യൂട്ട് ചെയ്യുന്നത് നിർത്തി TRUE തിരികെ നൽകുക // (php.ini ക്രമീകരണ ഫയലിലെ സെഷൻ.auto_start പാരാമീറ്റർ പ്രവർത്തനരഹിതമാക്കിയിരിക്കണം - ഡിഫോൾട്ട് മൂല്യം) (session_id()) നൽകുകയാണെങ്കിൽ true; മറ്റുള്ളവ തിരികെ സെഷൻ_സ്റ്റാർട്ട്(); // ശ്രദ്ധിക്കുക: പതിപ്പ് 5.3.0-ന് മുമ്പ്, ഒരു പിശക് സംഭവിച്ചാലും സെഷൻ_സ്റ്റാർട്ട്() ഫംഗ്‌ഷൻ TRUE നൽകി. // നിങ്ങൾ 5.3.0-ന് മുമ്പുള്ള പതിപ്പാണ് ഉപയോഗിക്കുന്നതെങ്കിൽ, ഒരു അധിക പരിശോധന നടത്തുക സെഷൻ_ഐഡി() എന്നതിനായി // സെഷൻ_സ്റ്റാർട്ട്() ) ഫംഗ്‌ഷൻ നശിപ്പിക്കുക സെഷൻ() ( എങ്കിൽ (സെഷൻ_ഐഡി()) ( // സജീവമായ ഒരു സെഷൻ ഉണ്ടെങ്കിൽ, സെഷൻ കുക്കികൾ ഇല്ലാതാക്കുക, setcookie(session_name(), session_id(), time( )-60*60*24); // കൂടാതെ സെഷൻ നശിപ്പിക്കുക സെഷൻ_അൺസെറ്റ്( ); session_destroy(); ) )

കുറിപ്പ്:വായനക്കാരന് PHP സെഷനുകളെക്കുറിച്ച് അടിസ്ഥാന അറിവ് ഉണ്ടെന്ന് അനുമാനിക്കപ്പെടുന്നു, അതിനാൽ ഞങ്ങൾ ഇവിടെ session_start(), session_destroy() ഫംഗ്‌ഷനുകളുടെ പ്രവർത്തന തത്വം ഉൾക്കൊള്ളുന്നില്ല. ലോഗിൻ ഫോമിൻ്റെയും ഉപയോക്തൃ പ്രാമാണീകരണത്തിൻ്റെയും ലേഔട്ടിൻ്റെ ചുമതലകൾ ലേഖനത്തിൻ്റെ വിഷയവുമായി ബന്ധപ്പെട്ടതല്ല, അതിനാൽ ഞങ്ങൾ അവയും ഒഴിവാക്കും. ഓരോ തുടർന്നുള്ള അഭ്യർത്ഥനയിലും ഉപയോക്താവിനെ തിരിച്ചറിയാൻ, വിജയകരമായ ലോഗിൻ നിമിഷത്തിൽ, ഞങ്ങൾ ഉപയോക്തൃ ഐഡൻ്റിഫയർ ഒരു സെഷൻ വേരിയബിളിൽ (ഉദാഹരണത്തിന്, userid എന്ന് വിളിക്കുന്നു) സംഭരിക്കേണ്ടതുണ്ടെന്ന് ഞാൻ നിങ്ങളെ ഓർമ്മിപ്പിക്കട്ടെ, അത് തുടർന്നുള്ള എല്ലാ അഭ്യർത്ഥനകളിലും ലഭ്യമാകും. സെഷൻ്റെ ജീവിതം. ഞങ്ങളുടെ സ്റ്റാർട്ട്‌സെഷൻ() ഫംഗ്‌ഷൻ്റെ ഫലം പ്രോസസ്സ് ചെയ്യുന്നത് നടപ്പിലാക്കേണ്ടതും ആവശ്യമാണ്. ഫംഗ്‌ഷൻ തെറ്റായി നൽകുകയാണെങ്കിൽ, ബ്രൗസറിൽ ലോഗിൻ ഫോം പ്രദർശിപ്പിക്കുക. ഫംഗ്‌ഷൻ TRUE നൽകി, അംഗീകൃത ഉപയോക്താവിൻ്റെ (ഞങ്ങളുടെ കാര്യത്തിൽ - userid) ഐഡൻ്റിഫയർ അടങ്ങുന്ന ഒരു സെഷൻ വേരിയബിൾ നിലവിലുണ്ടെങ്കിൽ - അംഗീകൃത ഉപയോക്താവിൻ്റെ പേജ് പ്രദർശിപ്പിക്കുക (പിശക് കൈകാര്യം ചെയ്യുന്നതിനെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്ക്, 2013-06-ലെ കൂട്ടിച്ചേർക്കൽ കാണുക- സെഷൻ വേരിയബിളുകളെക്കുറിച്ചുള്ള വിഭാഗത്തിൽ 07).

ഇതുവരെ എല്ലാം വ്യക്തമാണ്. നിങ്ങൾക്ക് ഉപയോക്തൃ നിഷ്‌ക്രിയത്വ നിയന്ത്രണം (സെഷൻ കാലഹരണപ്പെടൽ), ഒരു ബ്രൗസറിൽ ഒരേസമയം പ്രവർത്തിക്കാൻ ഒന്നിലധികം ഉപയോക്താക്കളെ പ്രാപ്‌തമാക്കുകയും സെഷനുകളെ അനധികൃത ഉപയോഗത്തിൽ നിന്ന് സംരക്ഷിക്കുകയും ചെയ്യേണ്ട സമയത്താണ് ചോദ്യങ്ങൾ ആരംഭിക്കുന്നത്. ഇത് താഴെ ചർച്ച ചെയ്യും.

അന്തർനിർമ്മിത PHP ടൂളുകൾ ഉപയോഗിച്ച് ഉപയോക്തൃ നിഷ്‌ക്രിയത്വം നിരീക്ഷിക്കുന്നു

ഉപയോക്താക്കൾക്കായി എല്ലാത്തരം കൺസോളുകളുടെയും ഡവലപ്പർമാർക്കിടയിൽ പലപ്പോഴും ഉയർന്നുവരുന്ന ആദ്യ ചോദ്യം, ഉപയോക്താവിൻ്റെ ഭാഗത്തുനിന്ന് നിഷ്ക്രിയത്വമുണ്ടായാൽ സെഷൻ യാന്ത്രികമായി അവസാനിപ്പിക്കുക എന്നതാണ്. PHP-യുടെ ബിൽറ്റ്-ഇൻ കഴിവുകൾ ഉപയോഗിച്ച് ഇത് ചെയ്യുന്നതിനേക്കാൾ എളുപ്പമുള്ള മറ്റൊന്നില്ല. (ഈ ഓപ്ഷൻ പ്രത്യേകിച്ച് വിശ്വസനീയമോ അയവുള്ളതോ അല്ല, പക്ഷേ ഞങ്ങൾ ഇത് പൂർണ്ണതയ്ക്കായി പരിഗണിക്കും).

പ്രവർത്തനം ആരംഭ സെഷൻ() ( // ഉപയോക്തൃ നിഷ്‌ക്രിയത്വ കാലഹരണപ്പെടൽ (സെക്കൻഡുകളിൽ) $sessionLifetime = 300; എങ്കിൽ (session_id()) true ആയി തിരികെ; // കുക്കി ലൈഫ് ടൈം ini_set("session.cookie_lifetime", $sessionLifetime) സജ്ജമാക്കുക; // ഉപയോക്താവാണെങ്കിൽ നിഷ്‌ക്രിയത്വ കാലഹരണപ്പെട്ടു, സെർവറിൽ സെഷൻ ലൈഫ് ടൈം സജ്ജീകരിക്കുക // ശ്രദ്ധിക്കുക: ഒരു പ്രൊഡക്ഷൻ സെർവറിന്, ($sessionLifetime) ini_set("session.gc_maxlifetime", $sessionLifetime) എങ്കിൽ php.ini ഫയലിൽ ഈ പരാമീറ്ററുകൾ പ്രീസെറ്റ് ചെയ്യാൻ ശുപാർശ ചെയ്യുന്നു ; എങ്കിൽ (session_start( )) (setcookie(session_name(), session_id(), time()+$sessionLifetime); true റിട്ടേൺ ചെയ്യുക; ) ഇല്ലെങ്കിൽ തെറ്റ് നൽകുക; )

കുറച്ച് വ്യക്തതകൾ. നിങ്ങൾക്കറിയാവുന്നതുപോലെ, അഭ്യർത്ഥന തലക്കെട്ടിൽ ബ്രൗസർ അയച്ച കുക്കി നാമം ഉപയോഗിച്ച് ഏത് സെഷൻ സമാരംഭിക്കണമെന്ന് PHP നിർണ്ണയിക്കുന്നു. സെർവറിൽ നിന്ന് ബ്രൗസറിന് ഈ കുക്കി ലഭിക്കുന്നു, അവിടെ സെഷൻ_സ്റ്റാർട്ട്() ഫംഗ്‌ഷൻ അത് സ്ഥാപിക്കുന്നു. ബ്രൗസർ കുക്കി കാലഹരണപ്പെട്ടാൽ, അത് അഭ്യർത്ഥനയിൽ അയയ്‌ക്കില്ല, അതിനർത്ഥം ഏത് സെഷൻ ആരംഭിക്കണമെന്ന് PHP ന് നിർണ്ണയിക്കാൻ കഴിയില്ലെന്നും ഇത് ഒരു പുതിയ സെഷൻ സൃഷ്‌ടിക്കുന്നതായി കണക്കാക്കുകയും ചെയ്യും. ഞങ്ങളുടെ ഉപയോക്തൃ നിഷ്‌ക്രിയത്വ കാലഹരണപ്പെടലിന് തുല്യമായി സജ്ജീകരിച്ചിരിക്കുന്ന PHP ക്രമീകരണ പാരാമീറ്റർ session.gc_maxlifetime, ഒരു PHP സെഷൻ്റെ ആയുസ്സ് സജ്ജീകരിക്കുകയും സെർവർ നിയന്ത്രിക്കുകയും ചെയ്യുന്നു. സെഷൻ ലൈഫ് ടൈം നിയന്ത്രിക്കുന്നത് ഇനിപ്പറയുന്ന രീതിയിൽ പ്രവർത്തിക്കുന്നു (പിഎച്ച്പിയിലെ ഏറ്റവും സാധാരണവും സ്ഥിരവുമായ ഓപ്ഷനായി താൽക്കാലിക ഫയലുകളിൽ സെഷനുകൾ സംഭരിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം ഞങ്ങൾ ഇവിടെ പരിഗണിക്കുന്നു).

ഒരു പുതിയ സെഷൻ സൃഷ്‌ടിക്കുമ്പോൾ, PHP ക്രമീകരണ പാരാമീറ്ററിലെ സെഷൻ സ്റ്റോറേജ് ഡയറക്‌ടറിയായി സെറ്റ് ചെയ്‌ത ഡയറക്‌ടറിയിൽ sess_ എന്ന ഫയൽ സൃഷ്‌ടിക്കപ്പെടും.save_path , എവിടെ - സെഷൻ ഐഡൻ്റിഫയർ. അടുത്തതായി, ഓരോ അഭ്യർത്ഥനയിലും, നിലവിലുള്ള ഒരു സെഷൻ സമാരംഭിക്കുന്ന സമയത്ത്, ഈ ഫയലിൻ്റെ പരിഷ്ക്കരണ സമയം PHP അപ്ഡേറ്റ് ചെയ്യുന്നു. അങ്ങനെ, തുടർന്നുള്ള ഓരോ അഭ്യർത്ഥനയിലും, സെഷൻ ഫയലിൻ്റെ നിലവിലെ സമയവും അവസാനമായി പരിഷ്കരിച്ച സമയവും തമ്മിലുള്ള വ്യത്യാസം അനുസരിച്ച്, സെഷൻ സജീവമാണോ അതോ അതിൻ്റെ ആയുസ്സ് ഇതിനകം കാലഹരണപ്പെട്ടതാണോ എന്ന് PHP-ന് നിർണ്ണയിക്കാനാകും. (പഴയ സെഷൻ ഫയലുകൾ ഇല്ലാതാക്കുന്നതിനുള്ള സംവിധാനം അടുത്ത വിഭാഗത്തിൽ കൂടുതൽ വിശദമായി ചർച്ചചെയ്യുന്നു.)

കുറിപ്പ്:സെഷൻ.gc_maxlifetime പാരാമീറ്റർ ഒരു സെർവറിനുള്ളിലെ എല്ലാ സെഷനുകൾക്കും ബാധകമാണെന്നത് ഇവിടെ ശ്രദ്ധിക്കേണ്ടതാണ് (കൂടുതൽ കൃത്യമായി പറഞ്ഞാൽ, ഒരു പ്രധാന PHP പ്രോസസ്സിനുള്ളിൽ). പ്രായോഗികമായി, ഇതിനർത്ഥം സെർവറിൽ നിരവധി സൈറ്റുകൾ പ്രവർത്തിക്കുന്നുണ്ടെങ്കിൽ, അവയിൽ ഓരോന്നിനും അതിൻ്റേതായ ഉപയോക്തൃ നിഷ്‌ക്രിയത്വ കാലഹരണപ്പെട്ടാൽ, സൈറ്റുകളിലൊന്നിൽ ഈ പാരാമീറ്റർ സജ്ജീകരിക്കുന്നത് മറ്റ് സൈറ്റുകൾക്കുള്ള ക്രമീകരണത്തിലേക്ക് നയിക്കും. പങ്കിട്ട ഹോസ്റ്റിംഗിനും ഇത് ബാധകമാണ്. ഈ സാഹചര്യം ഒഴിവാക്കാൻ, ഒരേ സെർവറിൽ ഓരോ സൈറ്റിനും പ്രത്യേക സെഷൻ ഡയറക്ടറികൾ ഉപയോഗിക്കുന്നു. php.ini ക്രമീകരണ ഫയലിലെ session.save_path പാരാമീറ്റർ ഉപയോഗിച്ചോ ini_set() ഫംഗ്‌ഷൻ വിളിച്ചോ ആണ് സെഷൻസ് ഡയറക്‌ടറിയിലേക്ക് പാത്ത് സജ്ജീകരിക്കുന്നത്. ഇതിനുശേഷം, ഓരോ സൈറ്റിൻ്റെയും സെഷനുകൾ വെവ്വേറെ ഡയറക്‌ടറികളിൽ സംഭരിക്കും, കൂടാതെ സൈറ്റുകളിലൊന്നിൽ സെഷൻ.gc_maxlifetime പാരാമീറ്റർ സെഷനിൽ മാത്രമേ സാധുതയുള്ളൂ. ഈ കേസ് ഞങ്ങൾ വിശദമായി പരിഗണിക്കില്ല, പ്രത്യേകിച്ചും ഉപയോക്തൃ നിഷ്‌ക്രിയത്വം നിരീക്ഷിക്കുന്നതിന് ഞങ്ങൾക്ക് കൂടുതൽ വഴക്കമുള്ള ഓപ്ഷൻ ഉള്ളതിനാൽ.

സെഷൻ വേരിയബിളുകൾ ഉപയോഗിച്ച് ഉപയോക്തൃ നിഷ്‌ക്രിയത്വം നിയന്ത്രിക്കുന്നു

മുമ്പത്തെ ഓപ്ഷൻ, അതിൻ്റെ എല്ലാ ലാളിത്യത്തിനും (രണ്ട് അധിക കോഡ് ലൈനുകൾ മാത്രം) നമുക്ക് ആവശ്യമുള്ളതെല്ലാം നൽകുന്നതായി തോന്നുന്നു. എന്നാൽ എല്ലാ അഭ്യർത്ഥനകളും ഉപയോക്തൃ പ്രവർത്തനത്തിൻ്റെ ഫലമായി കണക്കാക്കാൻ കഴിയുന്നില്ലെങ്കിൽ എന്തുചെയ്യും? ഉദാഹരണത്തിന്, സെർവറിൽ നിന്ന് അപ്‌ഡേറ്റുകൾ സ്വീകരിക്കുന്നതിന് കാലാകാലങ്ങളിൽ ഒരു AJAX അഭ്യർത്ഥന നടത്തുന്ന ഒരു ടൈമർ പേജിന് ഉണ്ട്. അത്തരമൊരു അഭ്യർത്ഥന ഉപയോക്തൃ പ്രവർത്തനമായി കണക്കാക്കാനാവില്ല, അതായത് സെഷൻ ആയുസ്സ് സ്വയമേവ നീട്ടുന്നത് ഈ സാഹചര്യത്തിൽ ശരിയല്ല. എന്നാൽ സെഷൻ_സ്റ്റാർട്ട്() ഫംഗ്‌ഷൻ വിളിക്കുമ്പോഴെല്ലാം സെഷൻ ഫയലിൻ്റെ പരിഷ്‌ക്കരണ സമയം PHP യാന്ത്രികമായി അപ്‌ഡേറ്റ് ചെയ്യുമെന്ന് ഞങ്ങൾക്കറിയാം, അതിനർത്ഥം ഏത് അഭ്യർത്ഥനയും സെഷൻ ആയുസ്സ് വർദ്ധിപ്പിക്കുന്നതിലേക്ക് നയിക്കുമെന്നും ഉപയോക്തൃ നിഷ്‌ക്രിയത്വ കാലഹരണപ്പെടൽ ഒരിക്കലും സംഭവിക്കില്ല. കൂടാതെ, session.gc_maxlifetime പാരാമീറ്ററിൻ്റെ സങ്കീർണതകളെക്കുറിച്ചുള്ള മുൻ വിഭാഗത്തിൽ നിന്നുള്ള അവസാന കുറിപ്പ് ചിലർക്ക് വളരെ ആശയക്കുഴപ്പമുള്ളതും നടപ്പിലാക്കാൻ ബുദ്ധിമുട്ടുള്ളതുമായി തോന്നിയേക്കാം.

ഈ പ്രശ്നം പരിഹരിക്കുന്നതിന്, ഞങ്ങൾ അന്തർനിർമ്മിത PHP മെക്കാനിസങ്ങളുടെ ഉപയോഗം ഉപേക്ഷിക്കുകയും ഉപയോക്തൃ നിഷ്‌ക്രിയത്വത്തിൻ്റെ സമയം സ്വയം നിയന്ത്രിക്കാൻ അനുവദിക്കുന്ന നിരവധി പുതിയ സെഷൻ വേരിയബിളുകൾ അവതരിപ്പിക്കുകയും ചെയ്യും.

പ്രവർത്തനം ആരംഭ സെഷൻ($isUserActivity=true) ($sessionLifetime = 300; എങ്കിൽ (session_id()) true എന്ന് തിരികെ നൽകുന്നു; // ബ്രൗസർ അടയ്‌ക്കുന്നതിന് മുമ്പ് കുക്കി ലൈഫ് ടൈം സജ്ജമാക്കുക (സെർവർ വശത്തുള്ള എല്ലാം ഞങ്ങൾ നിയന്ത്രിക്കും) ini_set ("സെഷൻ. cookie_lifetime", 0) ; എങ്കിൽ (! session_start()) false റിട്ടേൺ ചെയ്യുക; $t = time(); എങ്കിൽ ($sessionLifetime) ( // ഉപയോക്തൃ നിഷ്‌ക്രിയത്വ ടൈംഔട്ട് സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, // അവസാന ഉപയോക്തൃ പ്രവർത്തനത്തിന് ശേഷം കഴിഞ്ഞ സമയം പരിശോധിക്കുക // (ലാസ്റ്റ് ആക്ടിവിറ്റി സെഷൻ വേരിയബിൾ അപ്‌ഡേറ്റ് ചെയ്ത അവസാന അഭ്യർത്ഥന സമയം) എങ്കിൽ (ഇസെറ്റ്($_SESSION["lastactivity"]) && $t-$_SESSION["lastactivity"] >= $sessionLifetime) ( // സമയം കഴിഞ്ഞാൽ ഉപയോക്താവിൻ്റെ അവസാന പ്രവർത്തനം, // നിഷ്‌ക്രിയത്വ ടൈംഔട്ടിനേക്കാൾ വലുതാണ്, അതിനർത്ഥം സെഷൻ കാലഹരണപ്പെട്ടു, സെഷൻ അവസാനിപ്പിച്ച് നിങ്ങൾ സെഷൻ അവസാനിപ്പിക്കേണ്ടതുണ്ട് നശിപ്പിക്കുക സെഷൻ(); തെറ്റ് നൽകുക; ) അല്ലെങ്കിൽ ( // ടൈംഔട്ട് ഇതുവരെ സംഭവിച്ചിട്ടില്ലെങ്കിൽ, // ഒപ്പം ഉപയോക്തൃ പ്രവർത്തനത്തിൻ്റെ ഫലമായാണ് അഭ്യർത്ഥന വന്നതെങ്കിൽ, // ലാസ്റ്റ് ആക്ടിവിറ്റി വേരിയബിൾ നിലവിലെ ഒരു സമയത്തിൻ്റെ മൂല്യം ഉപയോഗിച്ച് അപ്‌ഡേറ്റ് ചെയ്യുക, // അതുവഴി മറ്റൊരു സെഷൻ ലൈഫ് ടൈം സെക്കൻ്റുകൾ കൊണ്ട് സെഷൻ സമയം നീട്ടുകയാണെങ്കിൽ ($isUserActivity) $_SESSION["lastactivity"] = $t; ) സത്യമായി മടങ്ങുക; )

നമുക്ക് സംഗ്രഹിക്കാം. ഓരോ അഭ്യർത്ഥനയിലും, അവസാന ഉപയോക്തൃ പ്രവർത്തനം മുതൽ നിലവിലെ നിമിഷം വരെ കാലഹരണപ്പെട്ടോ എന്ന് ഞങ്ങൾ പരിശോധിക്കുന്നു, അത് എത്തിയിട്ടുണ്ടെങ്കിൽ, ഞങ്ങൾ സെഷൻ നശിപ്പിക്കുകയും ഫംഗ്‌ഷൻ്റെ നിർവ്വഹണത്തെ തടസ്സപ്പെടുത്തുകയും തെറ്റായി നൽകുകയും ചെയ്യുന്നു. സമയപരിധിയിൽ എത്തിയിട്ടില്ലെങ്കിൽ, $isUserActivity പരാമീറ്റർ TRUE എന്ന മൂല്യം ഫംഗ്‌ഷനിലേക്ക് കൈമാറുകയാണെങ്കിൽ, ഉപയോക്താവിൻ്റെ അവസാന പ്രവർത്തനത്തിൻ്റെ സമയം ഞങ്ങൾ അപ്‌ഡേറ്റ് ചെയ്യും. അഭ്യർത്ഥന ഉപയോക്തൃ പ്രവർത്തനത്തിൻ്റെ ഫലമാണോ എന്ന് കോളിംഗ് സ്‌ക്രിപ്റ്റിൽ നിർണ്ണയിക്കുക, ഇല്ലെങ്കിൽ, $isUserActivity പാരാമീറ്റർ FALSE എന്ന് സജ്ജീകരിച്ച് startSession ഫംഗ്‌ഷനെ വിളിക്കുക മാത്രമാണ് ഞങ്ങൾ ചെയ്യേണ്ടത്.

2013-06-07 മുതൽ അപ്ഡേറ്റ്
സെഷൻസ്റ്റാർട്ട്() ഫംഗ്‌ഷൻ്റെ ഫലം പ്രോസസ്സ് ചെയ്യുന്നു
FALSE എന്ന് തിരികെ നൽകുന്നത് പിശകിൻ്റെ കാരണത്തെക്കുറിച്ച് പൂർണ്ണമായ ധാരണ നൽകുന്നില്ലെന്നും ഇത് തികച്ചും ന്യായമാണെന്നും അഭിപ്രായങ്ങൾ ചൂണ്ടിക്കാട്ടി. വിശദമായ പിശക് കൈകാര്യം ചെയ്യൽ ഞാൻ ഇവിടെ പ്രസിദ്ധീകരിച്ചിട്ടില്ല (ലേഖനത്തിൻ്റെ ദൈർഘ്യം ഇതിനകം തന്നെ വളരെ വലുതാണ്), കാരണം ഇത് ലേഖനത്തിൻ്റെ വിഷയവുമായി നേരിട്ട് ബന്ധപ്പെട്ടിട്ടില്ല. എന്നാൽ അഭിപ്രായങ്ങൾ നൽകിയാൽ, ഞാൻ വ്യക്തമാക്കും.
നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, സെഷൻസ്‌റ്റാർട്ട് ഫംഗ്‌ഷന് രണ്ട് സന്ദർഭങ്ങളിൽ FALSE നൽകാം. ഒന്നുകിൽ ചില ആന്തരിക സെർവർ പിശകുകൾ കാരണം സെഷൻ ആരംഭിക്കാൻ കഴിഞ്ഞില്ല (ഉദാഹരണത്തിന്, php.ini ലെ തെറ്റായ സെഷൻ ക്രമീകരണങ്ങൾ), അല്ലെങ്കിൽ സെഷൻ ആയുസ്സ് കാലഹരണപ്പെട്ടു. ആദ്യ സന്ദർഭത്തിൽ, സെർവറിൽ പ്രശ്‌നങ്ങളുണ്ടെന്നും പിന്തുണയുമായി ബന്ധപ്പെടുന്നതിനുള്ള ഒരു ഫോമും പ്രസ്താവിക്കുന്ന പിശകുള്ള ഒരു പേജിലേക്ക് ഞങ്ങൾ ഉപയോക്താവിനെ റീഡയറക്‌ട് ചെയ്യണം. രണ്ടാമത്തെ സാഹചര്യത്തിൽ, ഞങ്ങൾ ഉപയോക്താവിനെ ലോഗിൻ ഫോമിലേക്ക് മാറ്റുകയും സെഷൻ കാലഹരണപ്പെട്ടതായി പ്രസ്താവിക്കുന്ന അനുബന്ധ സന്ദേശം അതിൽ പ്രദർശിപ്പിക്കുകയും വേണം. ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾ പിശക് കോഡുകൾ നൽകുകയും FALSE എന്നതിന് പകരം അനുബന്ധ കോഡ് നൽകുകയും വേണം, കൂടാതെ കോളിംഗ് രീതിയിൽ, അത് പരിശോധിച്ച് അതിനനുസരിച്ച് പ്രവർത്തിക്കുക.

ഇപ്പോൾ, സെർവറിൽ ഒരു സെഷൻ നിലവിലുണ്ടെങ്കിലും, ഉപയോക്താവിൻ്റെ നിഷ്‌ക്രിയത്വ കാലഹരണപ്പെടൽ കാലഹരണപ്പെട്ടാൽ അത് ആദ്യമായി ആക്‌സസ് ചെയ്യുമ്പോൾ അത് നശിപ്പിക്കപ്പെടും. ആഗോള PHP ക്രമീകരണങ്ങളിൽ ഏത് സെഷൻ ലൈഫ് ടൈം സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിലും ഇത് സംഭവിക്കും.

കുറിപ്പ്:ബ്രൗസർ അടയ്‌ക്കുകയും സെഷൻ നാമം കുക്കി സ്വയമേവ നശിപ്പിക്കപ്പെടുകയും ചെയ്‌താൽ എന്ത് സംഭവിക്കും? അടുത്ത തവണ ബ്രൗസർ തുറക്കുമ്പോൾ സെർവറിലേക്കുള്ള അഭ്യർത്ഥനയിൽ സെഷൻ കുക്കികൾ അടങ്ങിയിരിക്കില്ല, കൂടാതെ സെർവറിന് സെഷൻ തുറക്കാനും ഉപയോക്താവിൻ്റെ നിഷ്‌ക്രിയത്വ സമയപരിധി പരിശോധിക്കാനും കഴിയില്ല. ഞങ്ങളെ സംബന്ധിച്ചിടത്തോളം, ഇത് ഒരു പുതിയ സെഷൻ സൃഷ്‌ടിക്കുന്നതിന് തുല്യമാണ്, ഇത് പ്രവർത്തനത്തെയോ സുരക്ഷയെയോ ഒരു തരത്തിലും ബാധിക്കില്ല. എന്നാൽ ന്യായമായ ഒരു ചോദ്യം ഉയർന്നുവരുന്നു - കാലഹരണപ്പെട്ടതിന് ശേഷം ഞങ്ങൾ അത് നശിപ്പിച്ചെങ്കിൽ ആരാണ് പഴയ സെഷൻ നശിപ്പിക്കുക? അല്ലെങ്കിൽ അത് ഇപ്പോൾ സെഷൻസ് ഡയറക്‌ടറിയിൽ എന്നെന്നേക്കുമായി തൂക്കിയിടുമോ? PHP-യിലെ പഴയ സെഷനുകൾ വൃത്തിയാക്കാൻ, മാലിന്യ ശേഖരണം എന്നൊരു സംവിധാനമുണ്ട്. സെർവറിലേക്കുള്ള അടുത്ത അഭ്യർത്ഥനയുടെ സമയത്ത് ഇത് പ്രവർത്തിക്കുകയും സെഷൻ ഫയലുകളുടെ അവസാന പരിഷ്ക്കരണ തീയതിയെ അടിസ്ഥാനമാക്കി എല്ലാ പഴയ സെഷനുകളും മായ്‌ക്കുകയും ചെയ്യുന്നു. എന്നാൽ സെർവറിലേക്കുള്ള എല്ലാ അഭ്യർത്ഥനകളിലും മാലിന്യ ശേഖരണ സംവിധാനം ആരംഭിക്കുന്നില്ല. വിക്ഷേപണത്തിൻ്റെ ആവൃത്തി (അല്ലെങ്കിൽ പകരം, പ്രോബബിലിറ്റി) നിർണ്ണയിക്കുന്നത് സെഷൻ.ജിസി_പ്രോബബിലിറ്റി, സെഷൻ.ജിസി_ഡിവൈസർ എന്നീ രണ്ട് ക്രമീകരണ പാരാമീറ്ററുകളാണ്. ആദ്യ പാരാമീറ്റർ രണ്ടാമത്തേത് കൊണ്ട് ഹരിക്കുന്നതിൻ്റെ ഫലം മാലിന്യ ശേഖരണ സംവിധാനം ആരംഭിക്കുന്നതിനുള്ള സാധ്യതയാണ്. അങ്ങനെ, സെർവറിലേക്കുള്ള ഓരോ അഭ്യർത്ഥനയ്‌ക്കൊപ്പവും സെഷൻ ക്ലിയറിംഗ് മെക്കാനിസം സമാരംഭിക്കുന്നതിന്, ഈ പരാമീറ്ററുകൾ തുല്യ മൂല്യങ്ങളിലേക്ക് സജ്ജമാക്കിയിരിക്കണം, ഉദാഹരണത്തിന് "1". ഈ സമീപനം ഒരു ക്ലീൻ സെഷൻ ഡയറക്‌ടറി ഉറപ്പുനൽകുന്നു, പക്ഷേ സെർവറിന് വളരെ ചെലവേറിയതാണ്. അതിനാൽ, പ്രൊഡക്ഷൻ സിസ്റ്റങ്ങളിൽ, session.gc_divisor-ൻ്റെ ഡിഫോൾട്ട് മൂല്യം 1000 ആയി സജ്ജീകരിച്ചിരിക്കുന്നു, അതായത്, മാലിന്യ ശേഖരണ സംവിധാനം 1/1000 എന്ന സംഭാവ്യതയോടെ പ്രവർത്തിക്കും. നിങ്ങളുടെ php.ini ഫയലിൽ നിങ്ങൾ ഈ ക്രമീകരണങ്ങൾ പരീക്ഷിക്കുകയാണെങ്കിൽ, മുകളിൽ വിവരിച്ച സാഹചര്യത്തിൽ, ബ്രൗസർ അതിൻ്റെ എല്ലാ കുക്കികളും അടച്ച് മായ്‌ക്കുമ്പോൾ, സെഷൻ ഡയറക്‌ടറിയിൽ കുറച്ച് സമയത്തേക്ക് പഴയ സെഷനുകൾ അവശേഷിക്കുന്നത് നിങ്ങൾ ശ്രദ്ധിച്ചേക്കാം. എന്നാൽ ഇത് നിങ്ങളെ വിഷമിപ്പിക്കേണ്ടതില്ല, കാരണം ... ഇതിനകം പറഞ്ഞതുപോലെ, ഇത് ഞങ്ങളുടെ മെക്കാനിസത്തിൻ്റെ സുരക്ഷയെ ഒരു തരത്തിലും ബാധിക്കില്ല.

2013-06-07 മുതൽ അപ്ഡേറ്റ്
സെഷൻ ഫയൽ ലോക്കിംഗ് കാരണം സ്ക്രിപ്റ്റുകൾ ഫ്രീസുചെയ്യുന്നത് തടയുന്നു
സെഷൻ ഫയൽ ബ്ലോക്ക് ചെയ്‌തതിനാൽ ഒരേസമയം പ്രവർത്തിക്കുന്ന സ്‌ക്രിപ്റ്റുകൾ ഫ്രീസുചെയ്യുന്നതിൻ്റെ പ്രശ്‌നമാണ് കമൻ്റുകൾ ഉന്നയിച്ചത് (ഏറ്റവും ശ്രദ്ധേയമായ ഓപ്ഷൻ ലോംഗ് പോൾ ആണ്).
ആരംഭിക്കുന്നതിന്, ഈ പ്രശ്നം സെർവർ ലോഡിനെയോ ഉപയോക്താക്കളുടെ എണ്ണത്തെയോ നേരിട്ട് ആശ്രയിക്കുന്നില്ലെന്ന് ഞാൻ ശ്രദ്ധിക്കുന്നു. തീർച്ചയായും, കൂടുതൽ അഭ്യർത്ഥനകൾ, സ്ക്രിപ്റ്റുകൾ സാവധാനത്തിൽ നടപ്പിലാക്കുന്നു. എന്നാൽ ഇത് പരോക്ഷമായ ആശ്രിതത്വമാണ്. ഒരു ഉപയോക്താവിന് വേണ്ടി സെർവറിന് നിരവധി അഭ്യർത്ഥനകൾ ലഭിക്കുമ്പോൾ, ഒരു സെഷനിൽ മാത്രമേ പ്രശ്നം ദൃശ്യമാകൂ (ഉദാഹരണത്തിന്, അവയിലൊന്ന് നീണ്ട വോട്ടെടുപ്പാണ്, ബാക്കിയുള്ളവ പതിവ് അഭ്യർത്ഥനകളാണ്). ഓരോ അഭ്യർത്ഥനയും ഒരേ സെഷൻ ഫയൽ ആക്സസ് ചെയ്യാൻ ശ്രമിക്കുന്നു, മുമ്പത്തെ അഭ്യർത്ഥന ഫയൽ അൺലോക്ക് ചെയ്തില്ലെങ്കിൽ, തുടർന്നുള്ള കാത്തിരിപ്പ് ഹാംഗ് ചെയ്യും.
സെഷൻ ഫയൽ ലോക്കിംഗ് പരമാവധി നിലനിർത്താൻ, സെഷൻ വേരിയബിളുകളുള്ള എല്ലാ പ്രവർത്തനങ്ങളും പൂർത്തിയായ ഉടൻ തന്നെ session_write_close() ഫംഗ്‌ഷനിലേക്ക് വിളിച്ച് സെഷൻ അവസാനിപ്പിക്കാൻ ശക്തമായി ശുപാർശ ചെയ്യുന്നു. പ്രായോഗികമായി, നിങ്ങൾ സെഷൻ വേരിയബിളുകളിൽ എല്ലാം സംഭരിക്കുകയും സ്ക്രിപ്റ്റിൻ്റെ എക്സിക്യൂഷനിലുടനീളം അവ ആക്സസ് ചെയ്യുകയും ചെയ്യരുത് എന്നാണ് ഇതിനർത്ഥം. നിങ്ങൾക്ക് സെഷൻ വേരിയബിളുകളിൽ കുറച്ച് വർക്കിംഗ് ഡാറ്റ സംഭരിക്കണമെങ്കിൽ, സെഷൻ ആരംഭിക്കുമ്പോൾ അവ ഉടൻ വായിക്കുക, പിന്നീടുള്ള ഉപയോഗത്തിനായി ലോക്കൽ വേരിയബിളുകളിൽ സംരക്ഷിച്ച് സെഷൻ അടയ്ക്കുക (അർത്ഥം session_write_close ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് സെഷൻ അടയ്ക്കുക, കൂടാതെ session_destroy ഉപയോഗിച്ച് നശിപ്പിക്കരുത്. ).
ഞങ്ങളുടെ ഉദാഹരണത്തിൽ, ഇതിനർത്ഥം, ഒരു സെഷൻ തുറന്ന്, അതിൻ്റെ ആയുസ്സും അംഗീകൃത ഉപയോക്താവിൻ്റെ നിലനിൽപ്പും പരിശോധിച്ച്, ആപ്ലിക്കേഷന് ആവശ്യമായ എല്ലാ അധിക സെഷൻ വേരിയബിളുകളും ഞങ്ങൾ വായിച്ച് സംരക്ഷിക്കണം (എന്തെങ്കിലും ഉണ്ടെങ്കിൽ), ഒരു കോൾ ഉപയോഗിച്ച് സെഷൻ അടയ്ക്കുക. സെഷൻ_write_close() എന്നതിലേക്ക് പോയി ഒരു സ്‌ക്രിപ്റ്റിൻ്റെ എക്‌സിക്യൂഷൻ തുടരുക, അത് ഒരു നീണ്ട വോട്ടെടുപ്പോ സാധാരണ അഭ്യർത്ഥനയോ ആകട്ടെ.

അനധികൃത ഉപയോഗത്തിൽ നിന്ന് സെഷനുകൾ സംരക്ഷിക്കുന്നു

നമുക്ക് സാഹചര്യം സങ്കൽപ്പിക്കാം. നിങ്ങളുടെ ഉപയോക്താക്കളിൽ ഒരാൾക്ക് ബ്രൗസർ കുക്കികളെ (ഞങ്ങളുടെ സെഷൻ സംഭരിച്ചിരിക്കുന്ന) കവർന്നെടുക്കുന്ന ഒരു ട്രോജൻ ലഭിക്കുകയും അത് നിർദ്ദിഷ്ട ഇമെയിലിലേക്ക് അയയ്ക്കുകയും ചെയ്യുന്നു. ആക്രമണകാരി കുക്കി നേടുകയും ഞങ്ങളുടെ അംഗീകൃത ഉപയോക്താവിൻ്റെ പേരിൽ ഒരു അഭ്യർത്ഥന കബളിപ്പിക്കാൻ അത് ഉപയോഗിക്കുകയും ചെയ്യുന്നു. ഈ അഭ്യർത്ഥന അംഗീകൃത ഉപയോക്താവിൽ നിന്ന് വന്നതുപോലെ സെർവർ വിജയകരമായി സ്വീകരിക്കുകയും പ്രോസസ്സ് ചെയ്യുകയും ചെയ്യുന്നു. IP വിലാസത്തിൻ്റെ അധിക സ്ഥിരീകരണം നടപ്പിലാക്കിയില്ലെങ്കിൽ, അത്തരം ആക്രമണം തുടർന്നുള്ള എല്ലാ അനന്തരഫലങ്ങളോടും കൂടി ഉപയോക്താവിൻ്റെ അക്കൗണ്ട് വിജയകരമായി ഹാക്ക് ചെയ്യപ്പെടുന്നതിന് ഇടയാക്കും.

എന്തുകൊണ്ടാണ് ഇത് സാധ്യമായത്? വ്യക്തമായും, സെഷൻ്റെ മുഴുവൻ ജീവിതകാലത്തും പേരും സെഷൻ ഐഡൻ്റിഫയറും എല്ലായ്‌പ്പോഴും ഒരുപോലെയാണ്, കൂടാതെ നിങ്ങൾക്ക് ഈ ഡാറ്റ ലഭിക്കുകയാണെങ്കിൽ, മറ്റൊരു ഉപയോക്താവിൻ്റെ പേരിൽ നിങ്ങൾക്ക് എളുപ്പത്തിൽ അഭ്യർത്ഥനകൾ അയയ്‌ക്കാൻ കഴിയും (തീർച്ചയായും, ഈ സെഷൻ്റെ ജീവിതകാലത്ത്). ഇത് ഏറ്റവും സാധാരണമായ ആക്രമണമായിരിക്കില്ല, പക്ഷേ സൈദ്ധാന്തികമായി ഇത് തികച്ചും പ്രായോഗികമാണെന്ന് തോന്നുന്നു, പ്രത്യേകിച്ചും അത്തരമൊരു ട്രോജനിന് ഉപയോക്താവിൻ്റെ ബ്രൗസർ കുക്കികൾ കൊള്ളയടിക്കാൻ അഡ്മിനിസ്ട്രേറ്റർ അവകാശങ്ങൾ പോലും ആവശ്യമില്ല.

ഇത്തരത്തിലുള്ള ആക്രമണങ്ങളിൽ നിന്ന് നിങ്ങൾക്ക് എങ്ങനെ സ്വയം പരിരക്ഷിക്കാം? വീണ്ടും, വ്യക്തമായും, സെഷൻ ഐഡൻ്റിഫയറിൻ്റെ ആയുസ്സ് പരിമിതപ്പെടുത്തുന്നതിലൂടെയും അതേ സെഷനിൽ ഇടയ്ക്കിടെ ഐഡൻ്റിഫയർ മാറ്റുന്നതിലൂടെയും. പഴയത് പൂർണ്ണമായും ഇല്ലാതാക്കി ഒരു പുതിയ സെഷൻ സൃഷ്ടിച്ച്, പഴയതിൽ നിന്ന് എല്ലാ സെഷൻ വേരിയബിളുകളും അതിലേക്ക് പകർത്തി സെഷൻ്റെ പേര് മാറ്റാനും നമുക്ക് കഴിയും. എന്നാൽ ഇത് സമീപനത്തിൻ്റെ സത്തയെ ബാധിക്കില്ല, അതിനാൽ ലാളിത്യത്തിനായി ഞങ്ങൾ സെഷൻ ഐഡൻ്റിഫയറിൽ മാത്രം പരിമിതപ്പെടുത്തും.

സെഷൻ ഐഡി ആയുസ്സ് കുറയുമ്പോൾ, ആക്രമണകാരിക്ക് ഒരു ഉപയോക്തൃ അഭ്യർത്ഥന കെട്ടിച്ചമയ്ക്കാൻ കുക്കികൾ നേടാനും ഉപയോഗിക്കാനുമുള്ള സമയം കുറയുമെന്ന് വ്യക്തമാണ്. ഓരോ അഭ്യർത്ഥനയ്ക്കും ഒരു പുതിയ ഐഡൻ്റിഫയർ ഉപയോഗിക്കേണ്ടതാണ്, അത് മറ്റൊരാളുടെ സെഷൻ ഉപയോഗിക്കുന്നതിനുള്ള സാധ്യത കുറയ്ക്കും. എന്നാൽ സെഷൻ ഐഡൻ്റിഫയർ റീജനറേഷൻ സമയം ഏകപക്ഷീയമായി സജ്ജീകരിക്കുമ്പോൾ ഞങ്ങൾ പൊതുവായ കേസ് പരിഗണിക്കും.

(ഇതിനകം ചർച്ച ചെയ്ത കോഡിൻ്റെ ഭാഗം ഞങ്ങൾ ഒഴിവാക്കും).

പ്രവർത്തനം ആരംഭ സെഷൻ($isUserActivity=true) (// സെഷൻ ഐഡൻ്റിഫയർ ലൈഫ്ടൈം $idLifetime = 60; ... എങ്കിൽ ($idLifetime) ( // സെഷൻ ഐഡൻ്റിഫയർ ലൈഫ്ടൈം സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, // സെഷൻ മുതൽ കഴിഞ്ഞ സമയം പരിശോധിക്കുക സൃഷ്ടിച്ചത് അല്ലെങ്കിൽ അവസാനത്തെ പുനർനിർമ്മാണം // (സെഷൻ വേരിയബിൾ സ്റ്റാർട്ട്ടൈം അപ്ഡേറ്റ് ചെയ്ത അവസാന അഭ്യർത്ഥനയുടെ സമയം) എങ്കിൽ (ഇസെറ്റ്($_SESSION["ആരംഭ സമയം"])) (($t-$_SESSION["ആരംഭ സമയം"]) >= $ idLifetime) ( // സെഷൻ ഐഡൻ്റിഫയറിൻ്റെ ആയുസ്സ് കാലഹരണപ്പെട്ട സമയം // ഒരു പുതിയ ഐഡൻ്റിഫയർ സൃഷ്‌ടിക്കുക session_regenerate_id(true); $_SESSION["starttime"] = $t; ) ) വേറെ ( // സെഷനിൽ ഇപ്പോൾ തന്നെ ഞങ്ങൾ ഇവിടെ എത്തും സൃഷ്‌ടിച്ചത് // സെഷൻ ഐഡൻ്റിഫയർ സൃഷ്‌ടിക്കുന്നതിനുള്ള സമയം $_SESSION["ആരംഭസമയം"] = $t; ) ) ശരിയായി തിരികെ നൽകുക; )

അതിനാൽ, ഒരു പുതിയ സെഷൻ സൃഷ്ടിക്കുമ്പോൾ (ഉപയോക്താവ് വിജയകരമായി ലോഗിൻ ചെയ്യുമ്പോൾ ഇത് സംഭവിക്കുന്നു), സെഷൻ വേരിയബിൾ ആരംഭ സമയം ഞങ്ങൾ സജ്ജമാക്കുന്നു, അത് സെഷൻ ഐഡൻ്റിഫയറിൻ്റെ അവസാന തലമുറയുടെ സമയം, നിലവിലെ സെർവർ സമയത്തിന് തുല്യമായ മൂല്യത്തിലേക്ക് സംഭരിക്കുന്നു. അടുത്തതായി, ഓരോ അഭ്യർത്ഥനയിലും, ഐഡൻ്റിഫയറിൻ്റെ അവസാന തലമുറയ്ക്ക് ശേഷം മതിയായ സമയം (idLifetime) കടന്നുപോയോ എന്ന് ഞങ്ങൾ പരിശോധിക്കുന്നു, അങ്ങനെയാണെങ്കിൽ, ഞങ്ങൾ പുതിയൊരെണ്ണം സൃഷ്ടിക്കുന്നു. അങ്ങനെ, ഐഡൻ്റിഫയറിൻ്റെ സെറ്റ് ലൈഫ് ടൈമിൽ അംഗീകൃത ഉപയോക്താവിൻ്റെ കുക്കി സ്വീകരിച്ച ആക്രമണകാരിക്ക് അത് ഉപയോഗിക്കാൻ സമയമില്ലെങ്കിൽ, വ്യാജ അഭ്യർത്ഥന സെർവർ അനധികൃതമായി കണക്കാക്കുകയും ആക്രമണകാരിയെ ലോഗിൻ പേജിലേക്ക് കൊണ്ടുപോകുകയും ചെയ്യും. .

കുറിപ്പ്: session_regenerate_id() ഫംഗ്‌ഷൻ വിളിക്കുമ്പോൾ പുതിയ സെഷൻ ഐഡി ബ്രൗസറിൻ്റെ കുക്കിയിൽ പ്രവേശിക്കുന്നു, അത് സെഷൻ_സ്റ്റാർട്ട്() ഫംഗ്‌ഷന് സമാനമായ പുതിയ കുക്കിയെ അയയ്‌ക്കുന്നു, അതിനാൽ ഞങ്ങൾ സ്വയം കുക്കി അപ്‌ഡേറ്റ് ചെയ്യേണ്ടതില്ല.

ഞങ്ങളുടെ സെഷനുകൾ കഴിയുന്നത്ര സുരക്ഷിതമാക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, ഐഡൻ്റിഫയറിൻ്റെ ആയുസ്സ് ഒന്നായി സജ്ജീകരിക്കുകയോ ബ്രാക്കറ്റുകളിൽ നിന്ന് സെഷൻ_റെജനറേറ്റ്_ഐഡി() ഫംഗ്‌ഷൻ നീക്കം ചെയ്യുകയും എല്ലാ ചെക്കുകളും നീക്കം ചെയ്യുകയും ചെയ്താൽ മതിയാകും, ഇത് ഓരോന്നിലും ഐഡൻ്റിഫയറിൻ്റെ പുനരുജ്ജീവനത്തിലേക്ക് നയിക്കും. അഭ്യർത്ഥന. (പ്രകടനത്തിൽ ഈ സമീപനത്തിൻ്റെ സ്വാധീനം ഞാൻ പരീക്ഷിച്ചിട്ടില്ല, കൂടാതെ session_regenerate_id(true) ഫംഗ്‌ഷൻ അടിസ്ഥാനപരമായി 4 പ്രവർത്തനങ്ങൾ മാത്രമേ ചെയ്യുന്നുള്ളൂ എന്ന് മാത്രമേ എനിക്ക് പറയാൻ കഴിയൂ: ഒരു പുതിയ ഐഡൻ്റിഫയർ സൃഷ്‌ടിക്കുക, സെഷൻ കുക്കി ഉപയോഗിച്ച് ഒരു തലക്കെട്ട് സൃഷ്‌ടിക്കുക, പഴയത് ഇല്ലാതാക്കുക, സൃഷ്‌ടിക്കുക ഒരു പുതിയ സെഷൻ ഫയൽ).

ലിറിക്കൽ ഡൈഗ്രഷൻ:ആക്രമണകാരിക്ക് കുക്കികൾ അയയ്‌ക്കാത്ത തരത്തിൽ ട്രോജൻ വളരെ മിടുക്കനാണെങ്കിൽ, കുക്കി ലഭിച്ചയുടനെ മുൻകൂട്ടി തയ്യാറാക്കിയ വ്യാജ അഭ്യർത്ഥന അയയ്‌ക്കുന്നത് സംഘടിപ്പിക്കുകയാണെങ്കിൽ, മുകളിൽ വിവരിച്ച രീതിക്ക് അത്തരത്തിൽ നിന്ന് പരിരക്ഷിക്കാൻ കഴിയില്ല. ഒരു ആക്രമണം, കാരണം ട്രോജൻ കുക്കി സ്വീകരിക്കുന്നതിനും വ്യാജ അഭ്യർത്ഥന അയയ്‌ക്കുന്നതിനും ഇടയിൽ പ്രായോഗികമായി വ്യത്യാസമൊന്നും ഉണ്ടാകില്ല, മാത്രമല്ല ഈ നിമിഷം സെഷൻ ഐഡൻ്റിഫയർ പുനർനിർമ്മിക്കപ്പെടാതിരിക്കാനുള്ള ഉയർന്ന സാധ്യതയുണ്ട്.

നിരവധി ഉപയോക്താക്കൾക്കായി ഒരു ബ്രൗസറിൽ ഒരേസമയം പ്രവർത്തിക്കാനുള്ള സാധ്യത

ഒരു ബ്രൗസറിൽ ഒരേസമയം നിരവധി ഉപയോക്താക്കൾക്ക് പ്രവർത്തിക്കാനുള്ള കഴിവാണ് ഞാൻ പരിഗണിക്കാൻ ആഗ്രഹിക്കുന്ന അവസാന ടാസ്ക്ക്. ഈ സവിശേഷത പരീക്ഷണ ഘട്ടത്തിൽ പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്, നിങ്ങൾക്ക് ഉപയോക്താക്കളുടെ ഒരേസമയം ജോലി അനുകരിക്കേണ്ടിവരുമ്പോൾ, ലഭ്യമായ മുഴുവൻ ആയുധശേഖരവും ഉപയോഗിക്കുന്നതിനോ അല്ലെങ്കിൽ ആൾമാറാട്ട മോഡിൽ ബ്രൗസറിൻ്റെ നിരവധി സന്ദർഭങ്ങൾ തുറക്കുന്നതിനോ പകരം നിങ്ങളുടെ പ്രിയപ്പെട്ട ബ്രൗസറിൽ ഇത് ചെയ്യുന്നതാണ് ഉചിതം. .

ഞങ്ങളുടെ മുൻ ഉദാഹരണങ്ങളിൽ, ഞങ്ങൾ ഒരു സെഷൻ നാമം വ്യക്തമായി വ്യക്തമാക്കിയിട്ടില്ല, അതിനാൽ സ്ഥിരസ്ഥിതി PHP നാമം (PHPSESSID) ഉപയോഗിച്ചു. ഇതിനർത്ഥം ഞങ്ങൾ ഇതുവരെ സൃഷ്ടിച്ച എല്ലാ സെഷനുകളും PHPSESSID എന്ന പേരിൽ ഒരു കുക്കി ബ്രൗസറിലേക്ക് അയച്ചു എന്നാണ്. വ്യക്തമായും, കുക്കിയുടെ പേര് എല്ലായ്പ്പോഴും സമാനമാണെങ്കിൽ, ഒരേ ബ്രൗസറിൽ ഒരേ പേരിൽ രണ്ട് സെഷനുകൾ സംഘടിപ്പിക്കാൻ ഒരു മാർഗവുമില്ല. എന്നാൽ ഓരോ ഉപയോക്താവിനും ഞങ്ങളുടെ സ്വന്തം സെഷൻ പേര് ഉപയോഗിച്ചാൽ, പ്രശ്നം പരിഹരിക്കപ്പെടും. അങ്ങനെ ചെയ്യാം.

ഫംഗ്ഷൻ സ്റ്റാർട്ട്സെഷൻ($isUserActivity=true, $prefix=null) (... എങ്കിൽ (session_id()) true റിട്ടേൺ ചെയ്യുക; // ഉപയോക്തൃ പ്രിഫിക്‌സ് പാരാമീറ്ററുകളിൽ പാസ്സാക്കിയിട്ടുണ്ടെങ്കിൽ, // ഇത് ഉൾപ്പെടുന്ന ഒരു അദ്വിതീയ സെഷൻ പേര് സജ്ജീകരിക്കുക പ്രിഫിക്‌സ്, // അല്ലാത്തപക്ഷം എല്ലാ ഉപയോക്താക്കൾക്കും പൊതുവായ പേര് സജ്ജീകരിക്കുക (ഉദാഹരണത്തിന്, MYPROJECT) session_name("MYPROJECT".($ prefix ? "_".$ prefix: "")); ini_set("session.cookie_lifetime", 0); എങ്കിൽ (! session_start()) തെറ്റ് തിരികെ നൽകുക; ... )

സ്റ്റാർട്ട്‌സെഷൻ() ഫംഗ്‌ഷനിലേക്ക് കോളിംഗ് സ്‌ക്രിപ്റ്റ് ഓരോ ഉപയോക്താവിനും ഒരു അദ്വിതീയ പ്രിഫിക്‌സ് നൽകുന്നുവെന്ന് ഉറപ്പാക്കുക എന്നതാണ് ഇപ്പോൾ അവശേഷിക്കുന്നത്. ഉദാഹരണത്തിന്, ഓരോ അഭ്യർത്ഥനയുടെയും GET/POST പാരാമീറ്ററുകളിൽ ഒരു പ്രിഫിക്‌സ് പാസുചെയ്യുന്നതിലൂടെയോ ഒരു അധിക കുക്കിയിലൂടെയോ ഇത് ചെയ്യാൻ കഴിയും.

ഉപസംഹാരം

ഉപസംഹാരമായി, മുകളിൽ ചർച്ച ചെയ്ത എല്ലാ ടാസ്ക്കുകളും ഉൾപ്പെടെ PHP സെഷനുകളിൽ പ്രവർത്തിക്കുന്നതിനുള്ള ഞങ്ങളുടെ പ്രവർത്തനങ്ങളുടെ പൂർണ്ണമായ അന്തിമ കോഡ് ഞാൻ നൽകും.

പ്രവർത്തനം ആരംഭ സെഷൻ($isUserActivity=true, $prefix=null) ($sessionLifetime = 300; $idLifetime = 60; എങ്കിൽ (session_id()) true റിട്ടേൺ ചെയ്യുക; session_name("MYPROJECT".($prefix ? "_".$prefix "")); ini_set("session.cookie_lifetime", 0); എങ്കിൽ (! session_start()) തെറ്റ് നൽകുക ) && $t-$_SESSION["lastactivity"] >= $sessionLifetime) (DestSession(); false തിരികെ നൽകുക; ) വേറെ (($isUserActivity) $_SESSION["lastactivity"] = $t; ) ) എങ്കിൽ ($idLifetime) ) ( എങ്കിൽ (ഇസെറ്റ്($_SESSION["ആരംഭസമയം"])) (($t-$_SESSION["ആരംഭസമയം"] >= $idLifetime) (സെഷൻ_regenerate_id(true); $_SESSION["starttime"] = $t; ) ) മറ്റുള്ളവ ($_SESSION["starttime"] = $t; ) ) true റിട്ടേൺ ചെയ്യുക; ) ഫംഗ്ഷൻ നശിപ്പിക്കുന്നുSession() ( if (session_id()) ( session_unset(); setcookie(session_name(), session_id(), time() -60*60*24); session_destroy(); ) )

ഈ ലേഖനം സെഷൻ മെക്കാനിസത്തെക്കുറിച്ച് ഒരിക്കലും ആഴത്തിൽ പരിശോധിക്കാത്തവർക്ക് കുറച്ച് സമയം ലാഭിക്കുമെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു, കൂടാതെ PHP-യുമായി പരിചയപ്പെടാൻ തുടങ്ങുന്നവർക്ക് ഈ സംവിധാനത്തെക്കുറിച്ച് മതിയായ ഉൾക്കാഴ്ച നൽകുകയും ചെയ്യും.