PHP
Sessions

Syntax

• void session_abort (void)
• int session_cache_expire ([string $ new_cache_expire])
• void session_commit (void)
• string session_create_id ([string $ prefix])
• bool session_decode (sträng $ data)
• bool session_destroy (ogiltig)
• string session_encode (void)
• int session_gc (ogiltigt)
• array session_get_cookie_params (ogiltigt)
• string session_id ([string $ id])
• bool session_is_registered (string $ name)
• string session_module_name ([string $ module])
• string session_name ([string $ name])
• bool session_regenerate_id ([bool $ delete_old_session = falsk])
• void session_register_shutdown (void)
• bool session_register (blandat $ namn [, blandat $ ...])
• void session_reset (void)
• string session_save_path ([string $ path])
• ogiltig session_set_cookie_params (int $ livstid [, sträng $ sökväg [, sträng $ domän [, bool $ säkert = falsk [, bool $ httponly = falsk]]]])
• bool session_set_save_handler (inräknbara $ öppen, avslutningsbar $ stäng, inräknbara $ läs, inräknbara $ skriv, inräknbara $ förstöra, inräknbara $ gc [, inräknbara $ create_sid [, inräknbara $ validate_sid [, inräknbara $ update_timestamp]]])
• bool session_start ([array $ optioner = []])
• int session_status (ogiltig)
• bool session_unregister (string $ name)
• void session_unset (void)
• void session_write_close (void)

Anmärkningar

Hantera sessiondata

$_SESSION är en matris och du kan hämta eller manipulera den som en vanlig matris.

<?php
// Starting the session
session_start();

// Storing the value in session
$_SESSION['id'] = 342;

// conditional usage of session values that may have been set in a previous session
if(!isset($_SESSION["login"])) {
    echo "Please login first";
    exit;
}
// now you can use the login safely
$user = $_SESSION["login"];

// Getting a value from the session data, or with default value, 
//     using the Null Coalescing operator in PHP 7
$name = $_SESSION['name'] ?? 'Anonymous';

Se även Manipulera en matris för mer information om hur man arbetar på en matris.

Observera att om du lagrar ett objekt i en session kan det hämtas graciöst endast om du har en klass autoloader eller om du redan har laddat klassen. Annars kommer objektet ut som typen __PHP_Incomplete_Class , vilket senare kan leda till kraschar . Se Namnavstånd och Autoladning om autoladning.

Varning:

Sessionsdata kan kapas. Detta beskrivs i: Pro PHP-säkerhet: Från principerna för applikationssäkerhet till implementeringen av XSS Defense - Kapitel 7: Förhindra kapning av sessioner Så det kan starkt rekommenderas att aldrig lagra någon personlig information i $_SESSION . Detta skulle mest kritiskt inkludera kreditkortsnummer , utfärdade ID-kort och lösenord ; men skulle också utvidga till mindre antagande data som namn , e-postmeddelanden , telefonnummer etc. som skulle göra det möjligt för en hacker att efterge sig / kompromissa med en legitim användare. Som en allmän regel använder du värdelösa / icke-personliga värden, till exempel numeriska identifierare, i sessiondata.

Förstör en hel session

Om du har en session som du vill förstöra kan du göra detta med session_destroy()

/*
    Let us assume that our session looks like this:
    Array([firstname] => Jon, [id] => 123)

    We first need to start our session:
*/
session_start();

/*
    We can now remove all the values from the `SESSION` superglobal:
    If you omitted this step all of the global variables stored in the 
    superglobal would still exist even though the session had been destroyed.
*/
$_SESSION = array();

// If it's desired to kill the session, also delete the session cookie.
// Note: This will destroy the session, and not just the session data!
if (ini_get("session.use_cookies")) {
    $params = session_get_cookie_params();
    setcookie(session_name(), '', time() - 42000,
        $params["path"], $params["domain"],
        $params["secure"], $params["httponly"]
    );
}

//Finally we can destroy the session:
session_destroy();

Att använda session_destroy() skiljer sig från att använda något som $_SESSION = array(); vilket tar bort alla värden lagrade i SESSION superglobal men det förstör inte den faktiska lagrade versionen av sessionen.

Obs : Vi använder $_SESSION = array(); istället för session_unset() eftersom manualen anger:

Använd endast session_unset () för äldre avskrivna koder som inte använder $ _SESSION.

session_start () Alternativ

Från och med PHP-sessioner kan vi skicka en matris med sessionbaserade php.ini alternativ till session_start funktionen.

Exempel

<?php
   if (version_compare(PHP_VERSION, '7.0.0') >= 0) {
       // php >= 7 version
       session_start([
          'cache_limiter' => 'private',
          'read_and_close' => true,
       ]);
   } else {
       // php < 7 version
       session_start();
   }
?>

Denna funktion introducerar också en ny php.ini inställning med namnet session.lazy_write , som som standard är true och innebär att sessiondata endast skrivs om, om de ändras.

Referens: https://wiki.php.net/rfc/session-lock-ini

Sessionens namn

Kontrollera om sessionskakor har skapats

Sessionsnamn är namnet på cookien som används för att lagra sessioner. Du kan använda detta för att upptäcka om cookies för en session har skapats för användaren:

if(isset($_COOKIE[session_name()])) {
    session_start();
}

Observera att den här metoden i allmänhet inte är användbar såvida du verkligen inte vill skapa cookies onödigt.

Ändrar sessionens namn

Du kan uppdatera sessionens namn genom att ringa session_name() .

//Set the session name
session_name('newname');
//Start the session
session_start();

Om inget argument ges i session_name() det aktuella sessionens namn.

Det bör endast innehålla alfanumeriska tecken; det ska vara kort och beskrivande (dvs. för användare med aktiverade cookievarningar). Sessionens namn kan inte bara bestå av siffror, minst en bokstav måste vara närvarande. Annars genereras en ny session-id varje gång.

Session Locking

Som vi alla är medvetna om att PHP skriver sessiondata till en fil på serversidan. När en begäran görs till php-skript som startar sessionen via session_start() , låser PHP denna sessionfil vilket resulterar i att blockera / vänta andra inkommande förfrågningar för samma session_id att slutföra, på grund av vilken de andra förfrågningarna fastnar på session_start() till eller såvida inte den låsta sessionfilen släpps

Sessionsfilen förblir låst tills skriptet är klart eller sessionen stängs manuellt. För att undvika denna situation, dvs för att förhindra att flera förfrågningar blockeras , kan vi starta sessionen och stänga sessionen som kommer att släppa låset från sessionfilen och låta fortsätta de återstående förfrågningarna.

// php < 7.0 
// start session 
session_start();

// write data to session
$_SESSION['id'] = 123; // session file is locked, so other requests are blocked

// close the session, release lock
session_write_close();

Nu kommer man att tänka om sessionen är stängd hur vi kommer att läsa sessionens värden, försköna även efter sessionen är stängd, sessionen är fortfarande tillgänglig. Så vi kan fortfarande läsa sessiondata.

echo $_SESSION['id'];    // will output  123

I php> = 7.0 kan vi ha sessionen read_only , read_write och lazy_write , så det kanske inte behövs session_write_close()

Safe Session Start utan fel

Många utvecklare har det här problemet när de arbetar med enorma projekt, särskilt om de arbetar med vissa modulära CMS på plugins, addons, komponenter etc. Här är lösningen för säker sessionstart där om först kontrolleras PHP-versionen för att täcka alla versioner och på nästa kontrolleras om sessionen startas. Om sessionen inte finns, startar jag sessionen säker. Om sessionen existerar händer ingenting.

if (version_compare(PHP_VERSION, '7.0.0') >= 0) {
    if(session_status() == PHP_SESSION_NONE) {
        session_start(array(
          'cache_limiter' => 'private',
          'read_and_close' => true,
       ));
    }
}
else if (version_compare(PHP_VERSION, '5.4.0') >= 0)
{
    if (session_status() == PHP_SESSION_NONE) {
        session_start();
    }
}
else
{
    if(session_id() == '') {
        session_start();
    }
}

Detta kan hjälpa dig mycket för att undvika session_start fel.