Prüfen Sie, ob PHP Sitzung hat bereits begonnen

Für Versionen von PHP vor PHP 5.4.0:

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

IMHO, sollten Sie wirklich überlegen, Ihren Sitzungsverwaltungscode zu überarbeiten, wenn Sie nicht wissen, ob eine Sitzung gestartet wird oder nicht ...

Meine Meinung ist jedoch subjektiv, und es gibt Situationen (Beispiele, die in den folgenden Kommentaren beschrieben werden), in denen möglicherweise nicht festgestellt werden kann, ob die Sitzung gestartet wird.

Mit PHP 5.4 wurde session_status () eingeführt, das zuverlässiger ist als die Verwendung von session_id().

Betrachten Sie den folgenden Ausschnitt:

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

Um zu prüfen, ob eine Sitzung gestartet wird, ist der empfohlene Weg in PHP 5.4 jetzt:

session_status() == PHP_SESSION_ACTIVE

sie können das tun, und es ist wirklich einfach.

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

Ich hoffe es hilft :)

Vor PHP 5.4 gibt es keine andere zuverlässige Methode als das Setzen eines globalen Flags.

Erwägen:

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

Oder:

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.

Vor PHP 5.4 sollten Sie also einen globalen Booleschen Wert festlegen.

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

Für alle PHP-Versionen

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

Überprüfen Sie dies :

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

Quelle http://php.net

Verwenden Sie session_id () , es wird eine leere Zeichenfolge zurückgegeben, wenn nicht festgelegt Es ist zuverlässiger als das Überprüfen des $_COOKIE.

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

Dies sollte für alle PHP Versionen funktionieren. Es ermittelt die Version PHP und prüft, ob die Sitzung basierend auf der Version PHP gestartet wird. Wenn die Sitzung nicht gestartet ist, wird sie gestartet.

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

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

ich hoffe es hilft !

Das einzige, was Sie tun müssen, ist:

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

Sie sind nicht sicher über die Effizienz einer solchen Lösung, aber dies ist vom Arbeitsprojekt Dies wird auch verwendet, wenn Sie die Standardsprache definieren müssen

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

@ vor einem Funktionsaufruf unterdrückt alle Fehler, die während des Funktionsaufrufs gemeldet werden.

Durch Hinzufügen eines @ vor session_start wird PHP angewiesen, das Drucken von Fehlermeldungen zu vermeiden.

Zum Beispiel:

Wenn Sie session_start() verwenden, nachdem Sie bereits etwas im Browser ausgedruckt haben, tritt ein Fehler auf, sodass PHP so etwas wie "Header können nicht gesendet werden: Begonnen um (Zeile 12)", @session_start() schlägt in diesem Fall weiterhin fehl, aber die Fehlermeldung wird nicht auf dem Bildschirm gedruckt.

Verwenden Sie vor dem Einfügen der Dateien oder dem Umleiten auf eine neue Seite die Funktion exit(), andernfalls wird ein Fehler ausgegeben.

Dieser Code kann in allen Fällen verwendet werden:

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

Sie sollten Ihren Code so reorganisieren, dass Sie session_start() genau einmal pro Seitenausführung aufrufen.

if (version_compare(PHP_VERSION, "5.4.0") >= 0) {
    $sess = session_status();
    if ($sess == PHP_SESSION_NONE) {
        session_start();
    }
} else {
    if (!$_SESSION) {
        session_start();
    }
}

Eigentlich ist es jetzt zu spät, um es hier zu erklären, da es gelöst wurde .. Dies war eine .inc-Datei eines meiner Projekte, in der Sie ein Menü für ein Restaurant konfigurieren, indem Sie ein Gericht auswählen und das Menü entfernen oder hinzufügen order . Der Server, an dem ich arbeitete, hatte nicht die aktuelle Version, also habe ich ihn flexibler gemacht. Es liegt an den Autoren, sie nutzen und ausprobieren zu wollen.

Funktioniert dieses Code-Snippet für Sie?

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

Auf PHP 5.3 funktioniert das für mich:

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

dann hast du Wenn Sie die Anweisung nicht auf if setzen, beginnt die Sitzung auf irgendeine Weise. Ich weiß nicht, warum. 

Antwort BASIERT auf @Meliza Ramos Response (siehe erste Antwort) und http://php.net/manual/de/function.phpversion.php , 

AKTIONEN:

• definiere PHP_VERSION_ID falls nicht vorhanden
• funktion definieren, um Version basierend auf PHP_VERSION_ID zu überprüfen
• definiere Funktion für openSession () sicher

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

Sie können die folgende Lösung verwenden, um zu überprüfen, ob bereits eine Sitzung PHP gestartet wurde:

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

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

Dies ist, was ich verwende, um festzustellen, ob eine Sitzung gestartet wurde. Verwenden Sie empty und isset wie folgt:

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

ich endete mit einer doppelten Überprüfung des Status. ph 5.4+

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

Entsprechend meiner Praxis müssen Sie vor dem Zugriff auf $_SESSION[] jedes Mal session_start aufrufen, um das Skript zu verwenden. Siehe den Link unten für ein Handbuch.

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

Für mich ist session_start als Name verwirrend. Ein session_load kann klarer sein.

PHP_VERSION_ID ist ab PHP 5.2.7 verfügbar. Überprüfen Sie dies also zuerst und erstellen Sie es gegebenenfalls. session_status ist ab PHP 5.4 verfügbar, daher müssen wir dies auch überprüfen:

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