PHP
Sessions

Syntaxe

• void session_abort (void)
• int session_cache_expire ([chaîne $ new_cache_expire])
• void session_commit (void)
• string session_create_id ([préfixe $ string])
• bool session_decode (chaîne $ data)
• bool session_destroy (void)
• string session_encode (void)
• int session_gc (void)
• array session_get_cookie_params (void)
• string session_id ([string $ id])
• bool session_is_registered (chaîne $ name)
• string session_module_name ([string $ module])
• string session_name ([string $ name])
• bool session_regenerate_id ([bool $ delete_old_session = false])
• void session_register_shutdown (vide)
• bool session_register (mix $ name [, mixed $ ...])
• void session_reset (void)
• string session_save_path ([string $ path])
• void session_set_cookie_params (int $ lifetime [, string $ path [, string $ domain [, bool $ secure = false [, bool $ httponly = false]]])
• bool session_set_save_handler (callable $ open, callable $ close, callable $ read, callable $ write, callable $ destroy, callable $ gc [, callable $ create_sid [, callable $ validate_sid [, callable $ update_timestamp]]])
• bool session_start ([array $ options = []])
• int session_status (void)
• bool session_unregister (chaîne $ name)
• void session_unset (void)
• void session_write_close (void)

Remarques

Manipulation des données de session

La $_SESSION est un tableau et vous pouvez le récupérer ou le manipuler comme un tableau normal.

<?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';

Voir également Manipulation d'un tableau pour plus d'informations sur l'utilisation d'un tableau.

Notez que si vous stockez un objet dans une session, il peut être récupéré gracieusement seulement si vous avez un chargeur automatique de classe ou si vous avez déjà chargé la classe. Sinon, l'objet sortira comme le type __PHP_Incomplete_Class , ce qui peut entraîner ultérieurement des plantages . Voir Espaces de noms et chargement automatique à propos du chargement automatique.

Attention:

Les données de session peuvent être détournées. Ceci est décrit dans: Sécurité PHP Pro: des principes de sécurité des applications à la mise en œuvre de XSS Defense - Chapitre 7: Prévention du détournement de session Il est donc fortement recommandé de ne jamais stocker d'informations personnelles dans $_SESSION . Cela comprend surtout les numéros de carte de crédit , les identifiants émis par le gouvernement et les mots de passe ; mais s’étendrait également à des données moins supposées telles que des noms , des e - mails , des numéros de téléphone , etc., ce qui permettrait à un pirate de se faire passer pour un utilisateur légitime. En règle générale, utilisez des valeurs sans valeur / non personnelles, telles que des identificateurs numériques, dans les données de session.

Détruire une session entière

Si vous avez une session que vous souhaitez détruire, vous pouvez le faire avec 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();

Utiliser session_destroy() est différent d'utiliser quelque chose comme $_SESSION = array(); qui enlèvera toutes les valeurs stockées dans la superglobal de SESSION mais ne détruira pas la version stockée réelle de la session.

Note : Nous utilisons $_SESSION = array(); au lieu de session_unset() car le manuel stipule:

Utilisez uniquement session_unset () pour les anciens codes obsolètes qui n'utilisent pas $ _SESSION.

Options session_start ()

A partir des sessions PHP, nous pouvons passer un tableau avec les options php.ini basées sur la session à la fonction session_start .

Exemple

<?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();
   }
?>

Cette fonctionnalité introduit également un nouveau paramètre php.ini nommé session.lazy_write , qui est défini par défaut sur true et signifie que les données de session ne sont réécrites que si elles changent.

Référencement: https://wiki.php.net/rfc/session-lock-ini

Nom de la session

Vérification de la création des cookies de session

Le nom de session est le nom du cookie utilisé pour stocker les sessions. Vous pouvez l'utiliser pour détecter si des cookies pour une session ont été créés pour l'utilisateur:

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

Notez que cette méthode n'est généralement pas utile à moins que vous ne souhaitiez vraiment pas créer des cookies inutilement.

Modification du nom de session

Vous pouvez mettre à jour le nom de la session en appelant session_name() .

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

Si aucun argument n'est fourni dans session_name() le nom de la session en cours est renvoyé.

Il ne doit contenir que des caractères alphanumériques. Il devrait être court et descriptif (pour les utilisateurs avec avertissements de cookies activés). Le nom de la session ne peut comporter que des chiffres, au moins une lettre doit être présente. Sinon, un nouvel identifiant de session est généré à chaque fois.

Verrouillage de session

Comme nous le savons tous, PHP écrit les données de session dans un fichier côté serveur. Quand une requête est faite au script php qui démarre la session via session_start() , PHP verrouille ce fichier de session qui bloque / attend les autres requêtes entrantes pour que le même session_id se termine, à cause de quoi les autres requêtes resteront bloquées sur session_start() ou à moins que le fichier de session verrouillé ne soit pas libéré

Le fichier de session reste verrouillé jusqu'à ce que le script soit terminé ou que la session soit fermée manuellement. Pour éviter cette situation, par exemple pour empêcher le blocage de plusieurs demandes , nous pouvons démarrer la session et fermer la session qui libère le verrou du fichier de session et permet de poursuivre les requêtes restantes.

// 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();

Maintenant, on va penser que si la session est fermée, comment on va lire les valeurs de la session, embellir même après la fermeture de la session, la session est toujours disponible. Nous pouvons donc toujours lire les données de session.

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

Dans php> = 7.0 , on peut avoir la session read_only, la session read_write et la session lazy_write , donc il ne sera peut-être pas nécessaire d'utiliser session_write_close()

Safe Session Start sans erreurs

Beaucoup de développeurs ont ce problème quand ils travaillent sur des projets énormes, surtout s'ils travaillent sur des CMS modulaires sur des plugins, addons, composants, etc. Voici la solution pour démarrer une session en toute sécurité. si la session est démarrée Si la session n'existe pas, je lance la session en toute sécurité. Si la session existe, rien ne se passe.

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();
    }
}

Cela peut vous aider beaucoup pour éviter l'erreur session_start .