Vérifiez si la session PHP a déjà démarré

J'ai un fichier PHP qui est parfois appelé à partir d'une page qui a démarré une session et parfois à partir d'une page qui n'a pas de session démarrée. Par conséquent, lorsque j'ai session_start()sur ce script, je reçois parfois le message d'erreur pour "session déjà démarrée". Pour cela j'ai mis ces lignes:

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

mais cette fois, j'ai reçu ce message d'avertissement:

Remarque: variable non définie: _SESSION

Existe-t-il un meilleur moyen de vérifier si la session a déjà commencé?

Si j'utilise @session_start, cela fera-t-il fonctionner correctement et fermera-t-il simplement les avertissements?

Méthode recommandée pour les versions de PHP> = 5.4.0, PHP 7

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

Référence: http://www.php.net/manual/en/function.session-status.php

Pour les versions de PHP <5.4.0

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

Pour les versions de PHP antérieures à PHP 5.4.0:

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

Cependant, à mon humble avis, vous devriez vraiment penser à refactoriser votre code de gestion de session si vous ne savez pas si une session est lancée ou non ...

Cela dit, mon opinion est subjective et il existe des situations (dont des exemples sont décrits dans les commentaires ci-dessous) où il peut ne pas être possible de savoir si la session a commencé.

PHP 5.4 introduit session_status () , qui est plus fiable que de s'appuyer sur session_id().

Considérez l'extrait de code suivant:

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

Donc, pour vérifier si une session est démarrée, la méthode recommandée en PHP 5.4 est maintenant:

session_status() == PHP_SESSION_ACTIVE

vous pouvez le faire, et c'est vraiment facile.

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

J'espère que cela aide :)

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

Avant PHP 5.4, il n'y a pas de moyen fiable de savoir autre que de définir un indicateur global.

Considérer:

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

Ou:

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.

Donc, avant PHP 5.4, vous devez définir un booléen global.

Pour toute version php

if ((function_exists('session_status') 
  && session_status() !== PHP_SESSION_ACTIVE) || !session_id()) {
  session_start();
}

Vérifiez ça :

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

Source http://php.net

Utilisez session_id () , il retourne une chaîne vide s'il n'est pas défini. C'est plus fiable que de vérifier le $_COOKIE.

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

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

J'espère que cela aide !

Cela devrait fonctionner pour toutes les versions de PHP. Il détermine la version PHP, puis vérifie si la session est démarrée en fonction de la version PHP. Ensuite, si la session n'est pas démarrée, elle la démarre.

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

La seule chose que vous devez faire est:

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

Je ne suis pas sûr de l'efficacité d'une telle solution, mais cela provient du projet en cours. Ceci est également utilisé si vous devez définir la langue par défaut

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

@ avant un appel de fonction supprime toutes les erreurs qui peuvent être signalées pendant l'appel de fonction.

L'ajout d'un @avant session_startindique à PHP d'éviter d'imprimer des messages d'erreur.

Par exemple:

L'utilisation d'une session_start()fois que vous avez déjà imprimé quelque chose dans le navigateur entraîne une erreur, donc PHP affichera quelque chose comme "les en-têtes ne peuvent pas être envoyés: démarré à (ligne 12)", @session_start()échouera toujours dans ce cas, mais le message d'erreur n'est pas imprimé sur écran.

Avant d'inclure les fichiers ou de rediriger vers une nouvelle page, utilisez la exit()fonction, sinon cela donnera une erreur.

Ce code peut être utilisé dans tous les cas:

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

Sur PHP 5.3, cela fonctionne pour moi:

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

alors vous avez. Si vous ne mettez pas le pas à si l'instruction commençant la session commencera de toute façon je ne sais pas pourquoi.

Réponse BASÉE sur @Meliza Ramos Response (voir première réponse) et http://php.net/manual/en/function.phpversion.php ,

ACTIONS:

• définir PHP_VERSION_ID s'il n'existe pas
• définir une fonction pour vérifier la version basée sur PHP_VERSION_ID
• définir la fonction pour sécuriser openSession ()

utilisez uniquement 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 fait, il est maintenant trop tard pour l'expliquer ici de toute façon car il a été résolu. Il s'agissait d'un fichier .inc d'un de mes projets où vous configurez un menu pour un restaurant en sélectionnant un plat et en supprimant / ajoutez ou modifiez la commande. Le serveur sur lequel je travaillais n'avait pas la version actuelle, je l'ai donc rendue plus flexible. C'est aux auteurs qui souhaitent l'utiliser et l'essayer.

Cet extrait de code vous convient-il?

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

Vous devez réorganiser votre code afin d'appeler session_start()exactement une fois par exécution de page.

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

PHP_VERSION_ID est disponible à partir de PHP 5.2.7, alors vérifiez d'abord et si nécessaire, créez-le. session_statusest disponible à partir de PHP 5.4, nous devons donc vérifier cela aussi:

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

Sur la base de ma pratique, avant d'accéder à la, $_SESSION[]vous devez appeler à session_startchaque fois pour utiliser le script. Voir le lien ci-dessous pour le manuel.

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

Pour moi au moins, session_startc'est déroutant comme nom. A session_loadpeut être plus clair.

je me suis retrouvé avec une double vérification de statut. php 5.4+

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

Vous pouvez utiliser la solution suivante pour vérifier si une session PHP a déjà démarré:

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

C'est ce que j'utilise pour déterminer si une session a commencé. En utilisant vide et isset comme suit:

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

Remplacez session_start();par:

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