Med hjälp av en PHP-session identifierar servern dig och låter dig utföra nödvändiga operationer: ändra information på olika webbsidor, lägga till ny information, etc. När du har avslutat arbetet med webbplatsen tar du bort den aktuella sessionen genom att klicka på knappen "Logga ut":
Vad är en PHP-session?
En PHP-session är ett sätt att lagra information i sessionsvariabler som kan användas för autentisering på flera webbsidor. Till skillnad från cookies lagras inte sessionsinformation på användarens dator. Istället skapar sessionen en fil på servern i en tillfällig katalog.
Denna information, som lagras under hela sessionen, är tillgänglig för alla webbsidor i resursen. På servern bestäms platsen för den temporära filen av parametern session.save_path i php.ini-konfigurationsfilen.
När du skapar en PHP-session utförs följande tre steg:
- När en session skapas genererar PHP en unik identifierare, som är en slumpmässig sträng med 32 hexadecimala tal. PHP-sessionens livstids-ID ser ut ungefär så här: 9c8foj87c3jj973actop1re472e8774;
- Servern skickar en cookie som kallas PHPSESSID till användarens dator för att lagra en unik sessionsidentifieringssträng;
- Servern genererar en fil i den angivna temporära katalogen som innehåller namnet på den unika sessionsidentifieraren med prefixet session_g. sess_9c8foj87c3jj973actop1re472e8774.
Dessa inställningar hjälper PHP-skript extrahera sessionsvariabelvärden från en fil. På klientsidan innehåller PHPSESSID sessionsidentifieraren. Den bekräftar namnet på filen som ska sökas i en specifik katalog på serversidan, från vilken sessionsvariabler kan extraheras och användas för verifiering.
Användaren kan avsluta sessionen genom att klicka på utloggningsknappen, som anropar session_destroy()-funktionen. När användaren stänger webbläsaren stängs PHP-sessionen automatiskt. Annars kommer servern att avsluta sessionen efter den angivna tidsperioden.
Sessionssyntax i PHP
När PHP auktoriserar genom en session skapas den med session_start()-funktionen och raderas med session_destroy()-funktionen. Global PHP-variabel, känd som $_SESSION, används för att ställa in värdena för sessionsvariabler. Du kan återställa alla värden som ställts in för sessionsvariabler med hjälp av session_unset()-funktionen.
Sessionsoperationer
Vi kommer att titta på följande operationer med hjälp av en PHP-session, samt exempel på dem.
- Starta en PHP-session och ställa in dess sessionsvariabler: en ny PHP-session startas med funktionen session_start() . När en session väl har skapats kan dess sessionsvariabler ställas in med $_SESSION. Vi har ställt in värdena för variablerna " användar-ID” — “php_user"och" lösenord” — “handledningar”:
Resultat: Om du kör ovanstående PHP-kod på servern får du följande meddelande:
- Hämta PHP-sessionsvariabelvärden: Det är möjligt att få värdena för de variabler som vi ställer in under senaste PHP auktoriseringssessioner. När vi öppnar en PHP-session i början av varje sida ( session_start()), måste koden nedan anges. Vi hämtar och visar dessa värden med den globala variabeln $_SESSION:
"; echo "Lösenord - " . $_SESSION["lösenord"] . "."; ?>
Resultat: När vi kör ovanstående PHP-kod på servern får vi följande meddelande som ett resultat. Värdena för sessionsvariablerna som vi ställde in tidigare efter att ha skapat PHP-sessionen visas.
- Uppdatering av PHP-sessionsvariabelvärden: Under en session kan du uppdatera värdena för dess variabler. Först måste vi öppna en PHP-session i början av varje sida ( session_start()). I koden nedan uppdaterar vi värdena för variablerna " användar-ID” — “new_php_user"och" lösenord” — “utbildning”.
Du kan skriva ut en rad sessionsvariabler och deras värden med funktionen print_r($ _SESSION), som visas nedan:
"; print_r($_SESSION); ?>
Resultat: När vi kör ovanstående PHP-kod på servern får vi följande meddelande. Den kommer att innehålla en rad sessionsvariabler med deras nya värden.
Webbplatssäkerhet bygger på sessionshantering. När en användare ansluter till en säker webbplats tillhandahåller de referenser, vanligtvis i form av ett användarnamn och lösenord. Webbservern har ingen aning om vilken användare som redan är inloggad eller hur de navigerar från sida till sida. Sessionsmekanismen tillåter användare att undvika att behöva ange ett lösenord varje gång de vill utföra en ny åtgärd eller gå till en ny sida.
I huvudsak säkerställer sessionshantering att den för närvarande anslutna användaren är den som autentiserades. Men tyvärr har sessioner blivit ett självklart mål för hackare eftersom de kan tillåta åtkomst till en webbserver utan behov av autentisering.
Efter att användaren har autentiserats förser webbservern honom med ett sessions-ID. Detta ID lagras i webbläsaren och ersätts närhelst autentisering behövs. Detta gör att du kan undvika upprepade inloggnings-/lösenordsinmatningsprocesser. Allt detta händer i bakgrund och orsakar inte obehag för användaren. Föreställ dig om du skrev in ditt användarnamn och lösenord varje gång du surfade ny sida!
I den här artikeln kommer jag att försöka beskriva alla sätt jag vet för att skydda sessions-ID:t i PHP.
Användning av cookies
Som standard skickas all sessionsinformation, inklusive ID, till cookien. Men detta händer inte alltid. Vissa användare inaktiverar cookies i sina webbläsare. I det här fallet skickar webbläsaren sessions-ID:t i URL:en.Här överförs ID:t i klartext, till skillnad från en session via en cookie, när informationen är gömd i HTTP-huvudet. Det mesta på ett enkelt sätt skydd från detta kommer att vara att förbjuda överföringen av sessionsidentifieraren genom adressfältet. Detta kan göras genom att skriva följande i Apache-serverns .htaccess-konfigurationsfil:
Php_flag session.use_only_cookies på
Använder kryptering
Om din webbplats måste behandla känslig information som siffror kreditkort(hej från Sony), du bör använda SSL3.0- eller TSL1.0-kryptering. För att göra detta, när du ställer in en cookie, måste du ange true för den säkra parametern.Om du lagrar sessionslösenordet i variabeln $_SESSION (det är fortfarande bättre att använda sql), bör du inte lagra det i klartext.
If ($_SESSION["lösenord"] == $userpass) ( // kod)
Ovanstående kod är inte säker eftersom lösenordet lagras som vanlig text i en sessionsvariabel. Använd istället md5-kryptering, ungefär så här:
If ($_SESSION["md5password"] == md5($userpass)) ( // kod )
Webbläsarkontroll
För att blockera möjligheten att använda en session från en annan webbläsare (dator), bör du kontrollera HTTP-rubrikfältet för användaragenten:Session_start(); if (isset($_SESSION["HTTP_USER_AGENT"])) (if ($_SESSION["HTTP_USER_AGENT"] != md5($_SERVER["HTTP_USER_AGENT"])) ( // kod ) ) else ( $_SESSION["HTTP_USER_AGENT" ] = md5($_SERVER["HTTP_USER_AGENT"] )
Sessionens utgångsdatum
Begränsa sessionens livslängd, såväl som cookiess livstid. Som standard är sessionslängden 1440 sekunder. Du kan ändra detta värde genom php.ini och .htaccess. Exempel för .htaccess:# Sessionens livslängd i sekunder
php_value session.gc_maxlifetime 3600
# Cookies livstid i sekunder
php_value session.cookie_lifetime 3600
Bindande med IP-adress
I vissa situationer (inte alltid) bör du binda med IP-adress. Främst när antalet användare är begränsat och har statiska IP-adresser. Kontrollen kan antingen baseras på listan över tillåtna IP-adresser,Include("ip_list.php"); //$ip_white_list = array ("admin1" => "111.222.333.444", "admin2" => "555.666.777.888"); if(!empty(array_search($_SERVER["REMOTE_ADDR"],$ip_white_list))) ( header("Plats: admin.php"); ) else ( echo "ACCESS DENY!"; )
Eller efter IP-adress för varje begäran (endast för statisk IP):
If(isset($_SESSION["ip"]) och $_SESSION["ip"] == $_SERVER["REMOTE_ADDR"]) ( header("Plats: admin.php"); ) else ( session_unset(); $ _SESSION["ip"] = $_SERVER["REMOTE_ADDR"] )
Du bör vara medveten om att hacking inte helt kan undvikas. Du kan bara göra detta hack så svårt som möjligt på alla kända sätt. Men du bör inte heller glömma bort dina lagliga användare, för att inte komplicera deras liv med sådant skydd.
Jag kan inte komma på varför, men försökte alla svar/googla.. Jag hittade inget. Här är situationen:
Localhost-kod
Resultat:
Konsekvent session_id() genom pages-applikationen och när sidan uppdateras. $_COOKIE["PHPSESSID"] matchar session_id()
Direkt server
Session_start();
Resultat:
echo session_id();
print_r($_COOKIE["PHPSESSID"]);
session_id() ändras vid varje begäran, omladdning av sida eller besök en annan sida. $_COOKIE["PHPSESSID"] är NULL/tom. Samma kod används överst på sidan. inget annat innehåll.
Det här problemet har gett mig en rejäl huvudvärk, vilken exakt serverkonfiguration eller fel kan orsaka detta? Varför är PHPSESSID-cookien tom, jag tror att det beror på att det associerade session_id() också återställs på varje begäran? All hjälp snälla killar! EDIT: Jag gjorde en enkel testfil med tre rader på lokal
fjärrserver
Observera: Odefinierat index: PHPSESSID i /home/vivaplug/public_html/dev/wp-content/plugins/test.php på rad 5
Google Chrome Headers
LOKALVÄRD
Request URL:http://localhost/wp-content/plugins/test.php Request Method:GET Status Code:200 OK Begär Headersview source Acceptera:text/html,application/xhtml+xml,application/xml;q=0.9, image/webp,*/*;q=0.8 Acceptera-Encoding:gzip,deflate,sdch Accept-Language:en-US,en;q=0.8 Cache-Control:no-cache Anslutning:keep-alive Cookie:PHPSESSID=68b7m4arpsacks4aetgmd3rs93 Värd:localhost Pragma:no-cache User-Agent:Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, som Gecko) Chrome/30.0.1599.101 Safari/537.36 Response Headersview source Cache-Control:no-store, no- cache, must-revalidate, post-check=0, pre-check=0 Anslutning:Keep-Alive Content-Type:text/html Datum:Tis, 05 Nov 2013 07:10:51 GMT Upphör att gälla:Tu, 19 Nov 1981 08 :52:00 GMT Keep-Alive:timeout=5, max=100 Pragma:no-cache Server:Apache/2.4.4 (Win32) PHP/5.4.16 Transfer-Encoding:chunked X-Powered-By:PHP/5.4 .16
BORT SERVER
Request URL:http://vivaplugins.com/dev/wp-content/plugins/test.php Request Method:GET Status Code:200 OK Request Headersview source Acceptera:text/html,application/xhtml+xml,application/xml; q=0.9,image/webp,*/*;q=0.8 Accept-Encoding:gzip,deflate,sdch Accept-Language:en-US,en;q=0.8 Cache-Control:max-age=0 Connection:keep- alive Host:vivaplugins.com User-Agent:Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, som Gecko) Chrome/30.0.1599.101 Safari/537.36 Svar HeadersView source Age:0 Cache-Control:no-store, no-store -cache, must-revalidate, post-check=0, pre-check=0 Content-Encoding:gzip Content-Type:text/html Datum:Tis, 05 Nov 2013 07:07:49 GMT Pragma:no-cache Server: Advanced Hosting av http://www.unixy.net/varnish Transfer-Encoding:chunked Vary:Accept-Encoding Via:1.1 lack X-Cache:HIT X-Cache-Hits:2 X-Cacheable:YES X-Powered-By :PHP/5.4.20 X-lack:1984840969 1984839805
Redan från början accepterade alla PHP med råge, men så fort ganska stora projekt började skapas på detta språk ställdes utvecklarna inför ett nytt problem – PHP saknade konceptet med globala variabler! Det vill säga, ett visst skript kördes, skickade den genererade sidan till klienten och alla resurser som användes av detta skript förstördes. Jag ska försöka illustrera: anta att det finns två sidor på en webbplats, index.php och dothings.php. Källorna för dessa sidor ser ut så här:
index.php dothings.phpOm vi kör dessa två skript, kommer vi på första sidan att se inskriptionen "Jag blev tilldelad index.php", och den andra sidan kommer att vara tom.
Webbplatsutvecklare, utan att tänka två gånger, började använda cookies för att lagra globala variabler på klientsidan. Processen såg ut ungefär så här: användaren kommer till webbplatsens huvudsida, gör några åtgärder, och all information som är associerad med denna användare, som kan behövas på andra sidor på webbplatsen, kommer att lagras i hans webbläsare i formuläret av kakor. Denna metod har ganska allvarliga nackdelar, på grund av vilka många utvecklare på en gång vände sig bort från PHP. Till exempel måste vi tillåta en användare att ge honom åtkomst till privata (eller privata) delar av webbplatsen. Du måste skicka en cookie till användaren, som kommer att fungera som hans efterföljande identifierare på webbplatsen. Detta tillvägagångssätt blir mycket besvärligt och obekvämt så fort sidan börjar samla in mer och mer information om användarens beteende, eftersom det är tillrådligt att koda all information som skickas till användaren så att den inte kan fejkas. Nyligen, genom att förfalska kakor, var det möjligt att "knacka" mer än en chatt, och ibland till och med smyga in i någon annans mail. Dessutom finns det fortfarande konstiga människor i världen vars webbläsare inte stöder cookies.
Jag kommer inte att gå in på de tekniska frågorna kring sessionsmekanismen, utan kommer bara att beskriva hur man korrekt arbetar med sessioner i PHP.
Hur arbetar man med sessioner?
Om du testar exemplen från artikeln (eller dina manus) på någon kommersiell hosting, bör det inte vara några problem med att arbeta med sessioner. Om du ställer in din server själv (oavsett om det är en riktig server eller en emulator), kan fel med något i stil med detta visas:
"Varning: öppen(/var/state/php/sess_6f71d1dbb52fa88481e752af7f384db0, O_RDWR) misslyckades: ingen sådan fil eller katalog (2)."
Detta betyder bara att din PHP är felaktigt konfigurerad. Du kan lösa detta problem genom att ange rätt sökväg (till en befintlig katalog) för att spara sessioner i filen php.ini och starta om servern.
Alla skript som använder variabler (data) från sessioner måste innehålla följande rad:
Session_start();
Detta kommando talar om för servern att en given sida behöver alla variabler som är associerade med en given användare (webbläsare). Servern tar dessa variabler från filen och gör dem tillgängliga. Det är mycket viktigt att öppna en session innan någon data skickas till användaren; i praktiken betyder det att det är tillrådligt att anropa session_start()-funktionen alldeles i början av sidan, till exempel så här:
Session_start(); ?>
... För att ställa in katalogen där sessionsfilerna ska sparas, använd session_save_path()-funktionen: session_save_path($_SERVER["DOCUMENT_ROOT"]."/session"); session_start();När sessionen startar kan du ställa in globala variabler.
index.php När ett värde tilldelas till valfritt fält i $_SESSION-matrisen, registreras en variabel med samma namn automatiskt som en sessionsvariabel. dothings.phpDenna array är tillgänglig på alla sidor som använder sessionen. Låt oss till exempel titta på programmet:
Allt är OK. Sessionen har laddats!Låt oss gå igenom och se vad som finns där:
När du kör dessa filer sekventiellt kommer det första skriptet "index.php" att ge följande resultat:Allt är OK. Sessionen har laddats! Låt oss gå igenom och se vad som finns där:
Och den andra "dothings.php" är denna: Jag blev ombedd att index.php Variabeln $a är nu tillgänglig på alla sidor på en given webbplats som har startat sessioner.
- Andra användbara funktioner
- och tekniker för att arbeta med sessioner: unset($_SESSION["a"])
- - sessionen "glömmer" värdet på den angivna sessionsvariabeln; session_destroy()
- - sessionen förstörs (till exempel om användaren lämnade systemet genom att klicka på knappen "logga ut"); session_set_cookie_params (int lifetime [, strängsökväg [, strängdomän]])
- med den här funktionen kan du ställa in hur länge sessionen ska "leva" genom att ställa in unix_timestamp, som bestämmer tiden för sessionens "död". Som standard är sessionen "live" tills klienten stänger webbläsarfönstret.
session_write_close() - registrera sessionsvariabler och stänga den. Detta är nödvändigt för att öppna webbplatsen i ett nytt fönster om sidan tar lång tid att bearbeta och har blockerat sessionsfilen för din webbläsare.
Exempel
Låt oss nu övergå till
Vårt exempel kommer att bestå av tre filer: index.php, authorize.php och secretplace.php. Filen index.php innehåller ett formulär där användaren anger sitt användarnamn och lösenord. Detta formulär skickar data till filen authorize.php, som, om auktoriseringen lyckas, tillåter användaren att komma åt filen secretplace.php, och annars kommer att visa ett felmeddelande.
Exempel: index.php
, du är på
hemlig sida
- Säkerhet
- Så vi kan skicka en identifierare från en sida (PHP-skript) till en annan (tills nästa samtal från vår sida), vilket innebär att vi kan skilja mellan alla webbplatsbesökare. Eftersom sessionsidentifieraren är ett mycket stort antal (128 bitar), finns det praktiskt taget ingen chans att den kan hittas med brute force. Därför lämnas angriparen med följande alternativ:
- det finns en trojan på användarens dator som stjäl sessionsnummer;
angriparen fångar upp trafik mellan användarens dator och servern. Naturligtvis finns det ett säkert (krypterat) SSL-protokoll, men det är inte alla som använder det;
En granne gick fram till vår användares dator och stal sessionsnumret.
- Sådana situationer, baserade på det faktum att någon stjäl något från någon annan, ligger i allmänhet inte inom programmerarens kompetens. Administratörer och användare bör själva ta hand om detta.
- PHP kan dock väldigt ofta "luras". Låt oss titta på möjliga hackpunkter i användarauktoriseringsprogrammet:
Filen authorize.php är ett försök att gissa ett lösenord med hjälp av ett tredjepartsskript; Filen secretplace.php är ett försök att lura programmet genom att ange värdena för variabeln $logged_user i webbläsarens adressfält, till exempel så här:"
"http://www.yoursite.ru/secretplace.php?
logged_user=hackerSå två "hål" är tydligt synliga i vårt program, det ena är litet och inte särskilt märkbart, men det andra är helt enkelt enormt, genom vilket de flesta hackare kommer in där de inte behöver gå.
Hur "lappar" man hål nummer 1? Vi kommer inte att skriva massor av kod för att blockera en IP-adress, etc., utan kolla helt enkelt var förfrågan kommer ifrån, eller snarare vilken sida förfrågan kom från, om det är någon sida från vår sida så är allt bra, men i alla andra fall Vi släpper inte in dig. Låt oss justera filen authorize.php: utgång; ) ) // om något var fel kommer användaren att få // ett felmeddelande.auktorisera.php V2
Låt oss säga att du har en webbplats där alla kan registrera sig för att skicka inlägg på ett forum. Naturligtvis har vissa användare (administratörer, moderatorer) fler möjligheter än andra, till exempel kan de radera meddelanden från andra användare. Du lagrar användarens åtkomstnivå i sessionen, i variabeln $user_status, där $user_status = 10 motsvarar full åtkomst till systemet. En angripare som kommer till webbplatsen behöver bara registrera sig på vanligt sätt och sedan lägga till i webbläsarens adressfält?user_status=10
.
Så du har en ny administratör på ditt forum! I princip kan vilken skriptvariabel som helst ställas in via adressfältet genom att helt enkelt lägga till ett frågetecken och namnet på variabeln med dess värde efter den fullständiga adressen till skriptet. Låt oss fixa vår kod för att undvika detta: Du angav fel lösenord!secretplace.php V2 variabel unset($_SESSION["loggad_användare"]);// öppna sessionen session_start();
- med den här funktionen kan du ställa in hur länge sessionen ska "leva" genom att ställa in unix_timestamp, som bestämmer tiden för sessionens "död". Som standard är sessionen "live" tills klienten stänger webbläsarfönstret.
?>/* du kan inte bara gå till den här sidan... om användarnamnet inte är registrerat, då omdirigerar vi honom till sidan index.php för att ange login och lösenord... här kan du faktiskt göra en massa saker, till exempel, kom ihåg användarens IP, och efter det tredje försöket att få tillgång till filer, blockera den. */ if(!isset($_SESSION["logged_user"]))( header("Plats: index.php"); exit; ) ?>
, du är på en hemlig sida!
Resultat
Sessionsmekanismen är en ganska bra funktion i PHP-språket. Sessionerna är enkla och mycket flexibla att använda. Förresten, det finns en, lite dokumenterad funktion hos PHP-sessioner (tillgänglig från och med version 4.0.3) - i sessioner kan du lagra inte bara variabler utan även objekt.
// Infoga SID automatiskt i länkar. ini_set("session.use_trans_sid", true); session_start(); ?>Klicka här!
Klicka här!!
// Ett exempel på att arbeta med sessioner. session_start(); // Om du precis har besökt sidan, återställ räknaren. om (!isset($_SESSION["count"])) $_SESSION["count"] = 0; //Öka räknaren i sessionen. $_SESSION["count"] = $_SESSION["count"] + 1; ?>
Sessionsmekanismen är en ganska bra funktion i PHP-språket. Sessionerna är enkla och mycket flexibla att använda. Förresten, det finns en, lite dokumenterad funktion hos PHP-sessioner (tillgänglig från och med version 4.0.3) - i sessioner kan du lagra inte bara variabler utan även objekt.
Disktid(er).Stäng din webbläsare för att nollställa räknaren.
?" target="_blank"> Öppna ett underordnat webbläsarfönster.
Sessioner i PHP är en mekanism för att lagra information om klientens dator på serversidan. Faktum är att sessioner i PHP inte är ett så komplext ämne, men för att förstå det måste du veta hur cookies fungerar i PHP. Så om du inte vet hur cookies fungerar i PHP, läs den relevanta artikeln först och kom sedan tillbaka hit.
Ordet session är översatt från engelska som session, så själva innebörden av sessioner i PHP blir tydligare, men programmerare har antagit termen "sessioner", och vi kommer att använda det i den här artikeln.
Sessioner i PHP är väldigt lika cookie-mekanismen, samma nyckel => värdepar, bara de lagras på serversidan.
session_start() funktion
Vi måste starta sessionen, för detta finns session_start()-funktionen. Denna funktion startar en session, eller session, vad du nu vill kalla den.
Det är tillrådligt att anropa session_start()-funktionen alldeles i början av sidan, men i mina exempel gör jag inte detta.
$_SESSION array
Sessioner är grupper av variabler som lagras på servern men som refererar till en unik besökare. Återigen, detta är nyckelpunkten: sessioner lagras på servern.
För att säkerställa att varje besökare interagerar med sin data från sin session används en cookie, kommandot för att skapa vilket PHP ger sig själv, du behöver inte oroa dig för det. Denna cookie är endast relevant för servern och kan inte användas för att erhålla användardata.
På servern lagras sessionsdata i en textfil och är tillgänglig i PHP-programmet i arrayen $_SESSION. För att spara en variabel i en session måste du tilldela den ett värde i den här arrayen.
Låt oss äntligen börja använda exempel. Det är väldigt enkelt.
Låt oss nu försöka få värdet från arrayen $_SESSION i ett annat exempel.
Observera att om vi i det andra exemplet tar bort session_start()-funktionen kommer vi inte att ha tillgång till data i $_SESSION-matrisen.
session_id() funktion
När en session har skapats har du automatiskt tillgång till sessionens unika identifierare med hjälp av session_id()-funktionen. Denna funktion låter dig både ställa in och få sessions-ID-värdet.
Du kan titta i utvecklarverktygsfältet i din webbläsare (i Chrome, tryck Ctrl + Skift + I, sedan Resurser, så hittar du en cookie där), den här domänen har satt en cookie för din webbläsare med namnet PHPSESSID och ungefär följande värde: "7g5df9rkd1hhvr33lq1k6c72p7".
Det är genom PHPSESSID-värdet som servern kommer att avgöra din webbläsare och arbeta med motsvarande uppsättning variabler som kommer att vara tillgängliga för skriptet genom $_SESSION-matrisen, som tidigare skrivits.
session_name() funktion
Medan session_id()-funktionen låter dig få sessions-ID-värdet, låter session_name()-funktionen dig få sessionsnamnet.
Återigen om session_start()-funktionen
Nu vet vi mer om hur sessioner fungerar i PHP och vi behöver återgå till session_start()-funktionen igen. Denna funktion initierar sessionsmekanismen för den aktuella användaren. Hur exakt händer detta:
- Om användaren startade webbplatsen för första gången ställer session_start() in en cookie på klienten och skapar tillfällig lagring på servern som är kopplad till användar-ID:t.
- Anger butiken som är kopplad till det aktuella ID som skickas in.
- Om det finns data i lagringen på servern placeras den i arrayen $_SESSION.
- Om register_globals från php.ini-filen är På, omvandlas alla element i $_SESSION-matrisen till globala variabler.
Exempel på sessionsanvändning
Nu ska vi titta på ett exempel som gör att vi kan genomföra små experiment med sessioner.
Disk
Du har öppnat en sida i den aktuella sessionenen gång.
Öppna exemplet i ">denna flik.
Allt sessionsarbete är baserat på $_SESSION-arrayen, detta är tydligt synligt i det här exemplet.
Om du stänger webbläsarfönstret avslutas sessionen och vår räknare nollställs. Detta beteende hos sessioner i PHP kan ändras, vi återkommer till denna fråga lite senare i artikeln.
Avsluta en session
För att avsluta sessionen behöver vi:
- Rensa $_SESSION-matrisen.
- Ta bort tillfällig lagring på servern.
- Ta bort sessionscookies.
Du kan rensa $_SESSION-matrisen med session_unset()-funktionen.
Funktionen session_destroy() tar bort tillfällig lagring på servern. För övrigt gör hon inget annat.
Du måste ta bort en sessionscookie med funktionen setcookie() som vi lärde oss i lektionen om att arbeta med cookies i PHP.
Exempel på att avsluta en session:
Sessionen har avslutats.
Nu kan du utföra ett experiment: kör ett exempel med en räknare i ett fönster, öka räknaren och kör sedan exemplet med att ta bort sessionen och uppdatera sidan med räknaren igen.
Du kan radera en cookiefil så här:
setcookie(session_name(), "", tid() - 60*60*24*32, "/")
Än en gång om funktionerna session_name() och session_id().
Funktionerna session_name() och session_id() används sällan i praktiken, men jag skriver om dem eftersom artikeln måste avslöja själva mekanismen för hur sessioner fungerar i PHP.
Genom att använda dessa funktioner kan du ställa in dina egna namn och sessions-ID, men detta rekommenderas inte. Om du ville ställa in dem, skriv sedan dessa funktioner med argument före session_start()-funktionen, som i exemplet nedan:
Med det här exemplet kommer alla användare att tilldelas samma sessions-ID.
Låt oss ta en närmare titt här: om du kör exemplet från avsnittet om funktionen session_name() (här är länken) i olika webbläsare (till exempel Chrome och Internet Explorer), så kommer varje webbläsare att ha sin egen unika sessionsidentifierare . Webbläsare lagrar cookies var och en i sin egen mapp, så session_start()-funktionen gör att varje webbläsare kan skapa sin egen unika identifierare och följaktligen skapas en unik lagring för varje webbläsare på servern. Därför kommer motexemplet (det här) att fungera oberoende i varje webbläsare.
Om du ställer in samma sessions-ID för alla användare kommer de att fungera med samma lagring på servern. Här är ett exempel på en räknare som räknar besök från olika webbläsare:
100) ( session_unset(); session_destroy(); ) ?>
Disk nr 2
Öppnade sidan i olika webbläsareen gång.
Öppna exemplet i ">denna flik.
Om du kör det här exemplet är det inte ett faktum att du kommer att se ett där. Andra besökare kan redan ha ändrat värdena i sessionsbutiken på servern. Jag vet inte när servern tar bort lagringen i det här fallet, så om räknaren överstiger 100 kommer jag att avsluta sessionen.
Ställa in väntetiden
Som standard är sessionen "live" tills besökaren stänger webbläsarfönstret. Detta beror på att session_start()-funktionen placerar en sådan cookie på klienten.
Sessionens livslängd kan ändras med session_set_cookie_params()-funktionen, här är dess syntax.
session_set_cookie_params (int lifetime [, strängsökväg [, strängdomän [, bool säker]]])
I praktiken räcker det att endast använda den första parametern (livstid), här skriver du ner tiden i sekunder, vilket avgör hur länge servern ska komma ihåg sessionstillståndet efter att webbläsaren stängts.
Effekten av session_set_cookie_params()-funktionen gäller endast för den period som skriptet körs.
Här är ett exempel på hur du använder den här funktionen:
Disk nr 3
Motvärde:.
Öppna räknaren i ">denna flik.
Rulla upp räknaren och stäng webbläsaren, öppna detta exempel igen efter 30 sekunder. Din session kommer att sparas.
