variable Compruebe si la sesión de PHP ya ha comenzado




session_start php ejemplos (20)

Tengo un archivo PHP que a veces se llama desde una página que ha iniciado una sesión y, a veces, desde una página que no ha iniciado sesión. Por lo tanto, cuando tengo session_start() en este script, a veces recibo el mensaje de error para "la sesión ya iniciada". Para eso he puesto estas líneas:

if(!isset($_COOKIE["PHPSESSID"]))
{
  session_start();
}

pero esta vez recibí este mensaje de advertencia:

Aviso: Variable indefinida: _SESSION

¿Hay una mejor manera de comprobar si la sesión ya ha comenzado?

Si uso @session_start hará que las cosas funcionen correctamente y solo @session_start las advertencias?


Use session_id() , devuelve una cadena vacía si no se establece. Es más confiable que consultar el $_COOKIE .

if (strlen(session_id()) < 1) {
    session_start();
}

if (session_id() === "") { session_start(); }

Espero eso ayude !


Para versiones de PHP anteriores a PHP 5.4.0:

if(session_id() == '') {
    // session isn't started
}

Sin embargo, en mi humilde opinión, realmente debería pensar en refactorizar su código de administración de sesión si no sabe si se inició o no una sesión ...

Dicho esto, mi opinión es subjetiva, y hay situaciones (ejemplos de las cuales se describen en los comentarios a continuación) donde puede que no sea posible saber si la sesión ha comenzado.


Esto debería funcionar para todas las versiones de PHP. Determina la versión de PHP, luego verifica si la sesión se inicia según la versión de PHP. Luego, si no se inicia la sesión, se inicia.

function start_session() {
  if(version_compare(phpversion(), "5.4.0") != -1){
    if (session_status() == PHP_SESSION_NONE) {
      session_start();
    }
  } else {
    if(session_id() == '') {
      session_start();
    }
  }
}

Mira esto :

<?php
/**
* @return bool
*/
function is_session_started()
{
    if ( php_sapi_name() !== 'cli' ) {
        if ( version_compare(phpversion(), '5.4.0', '>=') ) {
            return session_status() === PHP_SESSION_ACTIVE ? TRUE : FALSE;
        } else {
            return session_id() === '' ? FALSE : TRUE;
        }
    }
    return FALSE;
}

// Example
if ( is_session_started() === FALSE ) session_start();
?>

Fuente http://php.net


PHP 5.4 introdujo http://www.php.net/manual/en/function.session-status.php , que es más confiable que confiar en session_id() .

Considere el siguiente fragmento de código:

session_id('test');
var_export(session_id() != ''); // true, but session is still not started!
var_export(session_status() == PHP_SESSION_ACTIVE); // false

Por lo tanto, para verificar si se inicia una sesión, la forma recomendada en PHP 5.4 es ahora:

session_status() == PHP_SESSION_ACTIVE

Debe reorganizar su código para que llame a session_start() exactamente una vez por ejecución de página.


Antes de PHP 5.4, no hay otra forma confiable de saber que no sea establecer una bandera global.

Considerar:

var_dump($_SESSION); // null
session_start();
var_dump($_SESSION); // array
session_destroy();
var_dump($_SESSION); // array, but session isn't active.

O:

session_id(); // returns empty string
session_start();
session_id(); // returns session hash
session_destroy();
session_id(); // returns empty string, ok, but then
session_id('foo'); // tell php the session id to use
session_id(); // returns 'foo', but no session is active.

Por lo tanto, antes de PHP 5.4 debe establecer un booleano global.



Lo único que debes hacer es:

<?php
if(!isset($_SESSION))
{
session_start();
}
?>

Terminé con una doble verificación de estado. php 5.4+

if(session_status() !== PHP_SESSION_ACTIVE){session_start();};
if(session_status() !== PHP_SESSION_ACTIVE){die('session start failed');};

Respuesta BASADA en @Meliza Ramos Response (ver primera respuesta) y http://php.net/manual/en/function.phpversion.php ,

COMPORTAMIENTO:

  • define PHP_VERSION_ID si no existe
  • Definir la función para verificar la versión basada en PHP_VERSION_ID
  • Definir la función a openSession () segura.

solo usa openSession ()

    // PHP_VERSION_ID is available as of PHP 5.2.7, if our
    // version is lower than that, then emulate it
    if (!defined('PHP_VERSION_ID')) {
        $version = explode('.', PHP_VERSION);

        define('PHP_VERSION_ID', ($version[0] * 10000 + $version[1] * 100 + $version[2]));


        // PHP_VERSION_ID is defined as a number, where the higher the number
        // is, the newer a PHP version is used. It's defined as used in the above
        // expression:
        //
        // $version_id = $major_version * 10000 + $minor_version * 100 + $release_version;
        //
        // Now with PHP_VERSION_ID we can check for features this PHP version
        // may have, this doesn't require to use version_compare() everytime
        // you check if the current PHP version may not support a feature.
        //
        // For example, we may here define the PHP_VERSION_* constants thats
        // not available in versions prior to 5.2.7

        if (PHP_VERSION_ID < 50207) {
            define('PHP_MAJOR_VERSION',   $version[0]);
            define('PHP_MINOR_VERSION',   $version[1]);
            define('PHP_RELEASE_VERSION', $version[2]);

            // and so on, ...
        }
    }

    function phpVersionAtLeast($strVersion = '0.0.0')
    {
        $version = explode('.', $strVersion);

        $questionVer = $version[0] * 10000 + $version[1] * 100 + $version[2];

        if(PHP_VERSION_ID >= $questionVer)
            return true;
        else
            return false;

    }

    function openSession()
    {
        if(phpVersionAtLeast('5.4.0'))
        {
            if(session_status()==PHP_SESSION_NONE)
                session_start();
        }
        else // under 5.4.0
        {
            if(session_id() == '')
                session_start();
        }
    }

if (version_compare(phpversion(), '5.4.0', '<')) {
     if(session_id() == '') {
        session_start();
     }
 }
 else
 {
    if (session_status() == PHP_SESSION_NONE) {
        session_start();
    }
 }

Según mi práctica, antes de acceder a $_SESSION[] , debe llamar a session_start cada vez que use el script. Vea el siguiente enlace para el manual.

http://php.net/manual/en/function.session-start.php

Para mí al menos session_start es confuso como nombre. Una session_load puede ser más clara.


session_start();
if(!empty($_SESSION['user']))
{     
  //code;
}
else
{
    header("location:index.php");
}

No estoy seguro de la eficiencia de dicha solución, pero esto se debe a un proyecto en funcionamiento. También se usa si necesita definir el idioma predeterminado

   /**
    * Start session
    * Fall back to ukrainian language
    */
   function valid_session() {
    if(session_id()=='') {
        session_start();
        $_SESSION['lang']='uk';
        $_SESSION['lang_id']=3;
    }
    return true;
  }

En PHP 5.3 esto funciona para mí:

if(!strlen(session_id())){
    session_name('someSpecialName');
    session_start();
} 

entonces tiene. Si no pone la instrucción "no at if" al comienzo de la sesión, se iniciará de alguna manera, no sé por qué.


¿Es este fragmento de código de trabajo para usted?

if (!count($_SESSION)>0) {
    session_start();
}

Reemplace session_start(); con:

if (!isset($a)) {
    a = False;
    if ($a == TRUE) {
        session_start();
        $a = TRUE;
    }
}

Esto es lo que uso para determinar si una sesión ha comenzado. Mediante el uso de vacío y isset de la siguiente manera:

if (empty($_SESSION)  && !isset($_SESSION))  {
    session_start();
}




session-variables