PHP
Sesiones

Sintaxis

• 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 (string $ 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 (string $ 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 (void)
• bool session_register (mixed $ 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 $ abrir, callable $ cerrar, callable $ leer, callable $ escribir, callable $ destruir, callable $ gc [, callable $ create_sid [, callable $ validate_sid [, callable $ update_timestamp]])
• bool session_start ([array $ options = []])
• int session_status (void)
• bool session_unregister (string $ nombre)
• void session_unset (void)
• void session_write_close (void)

Observaciones

Manipulación de datos de sesión.

La variable $_SESSION es una matriz, y puede recuperarla o manipularla como una matriz 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';

También vea Manipular una matriz para obtener más información sobre cómo trabajar en una matriz.

Tenga en cuenta que si almacena un objeto en una sesión, solo se puede recuperar con gracia si tiene un autoloader de clase o si ya ha cargado la clase. De lo contrario, el objeto saldrá como el tipo __PHP_Incomplete_Class , que más tarde puede provocar bloqueos . Ver espacios de nombre y carga automática sobre carga automática.

Advertencia:

Los datos de sesión pueden ser secuestrados. Esto se describe en: Pro PHP Security: de los principios de seguridad de la aplicación a la implementación de XSS Defence - Capítulo 7: Prevención del secuestro de sesiones Por lo tanto, se recomienda encarecidamente que nunca almacene información personal en $_SESSION . Esto incluiría críticamente los números de tarjetas de crédito , los identificadores emitidos por el gobierno y las contraseñas ; pero también se extendería a datos menos confiables, como nombres , correos electrónicos , números de teléfono , etc., lo que permitiría a un pirata informático hacerse pasar por un usuario legítimo. Como regla general, utilice valores sin valor / no personales, como identificadores numéricos, en los datos de sesión.

Destruye toda una sesión.

Si tienes una sesión que deseas destruir, puedes hacerlo con 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();

Usar session_destroy() es diferente a usar algo como $_SESSION = array(); que eliminará todos los valores almacenados en la SESSION superglobal pero no destruirá la versión almacenada real de la sesión.

Nota : usamos $_SESSION = array(); En lugar de session_unset() porque el manual estipula:

Solo use session_unset () para el código obsoleto que no usa $ _SESSION.

Opciones de session_start ()

Comenzando con las sesiones de PHP, podemos pasar una matriz con opciones php.ini basadas en sesión a la función session_start .

Ejemplo

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

Esta característica también introduce una nueva configuración de php.ini llamada session.lazy_write , que por defecto es true y significa que los datos de la sesión solo se reescriben, si cambian.

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

Nombre de sesion

Comprobando si las cookies de sesión han sido creadas

Nombre de sesión es el nombre de la cookie utilizada para almacenar sesiones. Puede usar esto para detectar si se han creado cookies para una sesión para el usuario:

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

Tenga en cuenta que este método generalmente no es útil a menos que realmente no quiera crear cookies innecesariamente.

Cambio de nombre de sesión

Puede actualizar el nombre de la sesión llamando a session_name() .

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

Si no se proporciona ningún argumento en session_name() , se devuelve el nombre de la sesión actual.

Debe contener solo caracteres alfanuméricos; debe ser breve y descriptivo (es decir, para usuarios con advertencias de cookies habilitadas). El nombre de la sesión no puede constar de dígitos solamente, por lo menos una letra debe estar presente. De lo contrario, cada vez se genera un nuevo ID de sesión.

Bloqueo de sesión

Como todos sabemos, PHP escribe datos de sesión en un archivo en el lado del servidor. Cuando se realiza una solicitud al script php que inicia la sesión a través de session_start() , PHP bloquea este archivo de sesión que resulta en bloquear / esperar otras solicitudes entrantes para que se complete la misma session_id , debido a que las otras solicitudes se atascarán en session_start() hasta que o a menos que el archivo de sesión bloqueado no se libere

El archivo de sesión permanece bloqueado hasta que el script se completa o la sesión se cierra manualmente. Para evitar esta situación, es decir, para evitar que se bloqueen varias solicitudes , podemos iniciar la sesión y cerrar la sesión, lo que liberará el bloqueo del archivo de sesión y permitirá continuar con las solicitudes 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();

Ahora, uno pensará que si la sesión está cerrada, cómo leeremos los valores de la sesión, se embellecerá incluso después de cerrar la sesión, la sesión aún estará disponible. Por lo tanto, todavía podemos leer los datos de la sesión.

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

En php> = 7.0 , podemos tener read_only session, read_write session y lazy_write session, por lo que puede que no sea necesario utilizar session_write_close()

Inicio de sesión segura sin errores

Muchos desarrolladores tienen este problema cuando trabajan en grandes proyectos, especialmente si trabajan en algunos CMS modulares en complementos, complementos, componentes, etc. Esta es la solución para el inicio seguro de la sesión donde, si primero se verificó la versión de PHP para cubrir todas las versiones, se verifica la siguiente. si se inicia sesion Si la sesión no existe, entonces inicio la sesión segura. Si existe sesión no pasa nada.

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

Esto puede ayudarte mucho para evitar el error session_start .