Compruebe si la sesión PHP ya ha comenzado

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 tiene sesión iniciada. Por lo tanto, cuando tengo session_start()este script, a veces recibo el mensaje de error para "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 verificar si la sesión ya ha comenzado?

Si lo uso, ¿ @session_starthará que las cosas funcionen correctamente y simplemente cerrará las advertencias?

Forma recomendada para versiones de PHP> = 5.4.0, PHP 7

if (session_status() == PHP_SESSION_NONE) {
    session_start();
}

Referencia: http://www.php.net/manual/en/function.session-status.php

Para versiones de PHP <5.4.0

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

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 el código de administración de la sesión si no sabe si una sesión se inicia o no ...

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

PHP 5.4 introdujo session_status () , que es más confiable que confiar en él session_id().

Considere el siguiente fragmento:

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

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

session_status() == PHP_SESSION_ACTIVE

puedes hacer esto, y es realmente fácil.

if (!isset($_SESSION)) session_start();

Espero eso ayude :)

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

Antes de PHP 5.4, no hay una forma confiable de conocer más que 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.

Entonces, antes de PHP 5.4, debe establecer un valor booleano global.

Para todas las versiones de php

if ((function_exists('session_status') 
  && session_status() !== PHP_SESSION_ACTIVE) || !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

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

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

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

Espero eso ayude !

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 la sesión no se inicia, la 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();
    }
  }
}

Lo único que debes hacer es:

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

No estoy seguro de la eficacia de dicha solución, pero esto es del proyecto en funcionamiento. Esto 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;
  }

@ antes de que una llamada a función suprima cualquier error que pueda ser reportado durante la llamada a función.

Agregar un @antessession_start le dice a PHP que evite imprimir mensajes de error.

Por ejemplo:

El uso session_start()después de que ya haya impreso algo en el navegador da como resultado un error, por lo que PHP mostrará algo como "no se pueden enviar encabezados: comenzó en (línea 12)",@session_start() aún fallará en este caso, pero el mensaje de error no se imprime en pantalla.

Antes de incluir los archivos o redirigir a una nueva página, use el exit() función; de lo contrario, se producirá un error.

Este código se puede usar en todos los casos:

    <?php 
        if (session_status() !== PHP_SESSION_ACTIVE || session_id() === ""){
            session_start(); 
        }
    ?>

En PHP 5.3 esto funciona para mí:

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

entonces tiene. Si no pone la declaración de no comenzar si la sesión comenzará de alguna manera, no sé por qué.

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
• defina la función para verificar la versión basada en PHP_VERSION_ID
• define la función para openSession () seguro

solo use 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(PHP_VERSION, "5.4.0") >= 0) {
    $sess = session_status();
    if ($sess == PHP_SESSION_NONE) {
        session_start();
    }
} else {
    if (!$_SESSION) {
        session_start();
    }
}

En realidad, ahora es demasiado tarde para explicarlo aquí de todos modos, ya que se ha resuelto. Este fue un archivo .inc de uno de mis proyectos donde configuró un menú para un restaurante seleccionando un plato y eliminando / agregando o cambiando el orden. El servidor en el que estaba trabajando no tenía la versión real, así que lo hice más flexible. Depende de los autores que deseen usarlo y probarlo.

¿Te sirve este fragmento de código?

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

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

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

PHP_VERSION_ID está disponible a partir de PHP 5.2.7, así que verifíquelo primero y, si es necesario, créelo . session_statusestá disponible a partir de PHP 5.4, así que tenemos que verificar esto también:

if (!defined('PHP_VERSION_ID')) {
    $version = explode('.', PHP_VERSION);
    define('PHP_VERSION_ID', ($version[0] * 10000 + $version[1] * 100 + $version[2]));
}else{
    $version = PHP_VERSION_ID;
}
if($version < 50400){
    if(session_id() == '') {
        session_start();
    }
}else{
    if (session_status() !== PHP_SESSION_ACTIVE) {
        session_start();
    }
}

Según mi práctica, antes de acceder al $_SESSION[]debe llamar session_startcada vez para usar el script. Consulte el siguiente enlace para ver el manual.

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

Para mí al menos session_startes confuso como un nombre. A session_loadpuede ser más claro.

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

Puede usar la siguiente solución para verificar si una sesión PHP ya ha comenzado:

if(session_id()== '')
{
   echo"Session isn't Start";
}
else
{
    echo"Session Started";
}

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

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

Reemplazar session_start();con:

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