Sprawdź, czy sesja PHP już się rozpoczęła

Mam plik PHP, który jest czasami wywoływany ze strony, która rozpoczęła sesję, a czasami ze strony, która nie rozpoczęła sesji. Dlatego gdy mam session_start()ten skrypt, czasami pojawia się komunikat o błędzie „sesja już się rozpoczęła”. W tym celu umieściłem następujące linie:

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

ale tym razem dostałem ten komunikat ostrzegawczy:

Uwaga: Niezdefiniowana zmienna: _SESSION

Czy istnieje lepszy sposób sprawdzenia, czy sesja już się rozpoczęła?

Jeśli użyję, @session_startczy to zadziała poprawnie i po prostu zamknie ostrzeżenia?

Zalecany sposób dla wersji PHP> = 5.4.0, PHP 7

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

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

Dla wersji PHP <5.4.0

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

W przypadku wersji PHP wcześniejszych niż PHP 5.4.0:

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

Chociaż, IMHO, naprawdę powinieneś pomyśleć o refaktoryzacji kodu zarządzania sesją, jeśli nie wiesz, czy sesja się rozpocznie ...

To powiedziawszy, moja opinia jest subiektywna i zdarzają się sytuacje (których przykłady opisano w komentarzach poniżej), w których może nie być możliwe ustalenie, czy sesja się rozpoczęła.

PHP 5.4 wprowadził session_status () , który jest bardziej niezawodny niż poleganie na nim session_id().

Rozważ następujący fragment kodu:

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

Tak więc, aby sprawdzić, czy sesja się rozpoczyna, zalecanym sposobem w PHP 5.4 jest teraz:

session_status() == PHP_SESSION_ACTIVE

możesz to zrobić i to jest naprawdę łatwe.

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

Mam nadzieję, że to pomoże :)

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

W wersjach wcześniejszych niż PHP 5.4 nie ma innej wiarygodnej metody niż ustawienie flagi globalnej.

Rozważać:

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

Lub:

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.

Tak więc przed PHP 5.4 powinieneś ustawić globalną wartość logiczną.

Dla wszystkich wersji php

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

Sprawdź to :

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

Źródło http://php.net

Użyj session_id () , zwraca pusty ciąg, jeśli nie jest ustawiony. Jest bardziej niezawodny niż sprawdzanie $_COOKIE.

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

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

mam nadzieję, że to pomoże !

Powinno to działać dla wszystkich wersji PHP. Określa wersję PHP, a następnie sprawdza, czy sesja jest uruchamiana na podstawie wersji PHP. Następnie, jeśli sesja nie zostanie uruchomiona, rozpocznie się.

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

Jedyne, co musisz zrobić, to:

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

Nie jestem pewien co do wydajności takiego rozwiązania, ale pochodzi z działającego projektu. Jest to również używane, jeśli musisz zdefiniować domyślny język

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

@ przed wywołaniem funkcji pomija wszelkie błędy, które mogą być zgłaszane podczas wywołania funkcji.

Dodanie @wcześniej session_startmówi PHP, aby uniknąć drukowania komunikatów o błędach.

Na przykład:

Używanie session_start()po tym, jak już coś wydrukowałeś w przeglądarce, powoduje błąd, więc PHP wyświetli coś takiego: „nagłówki nie mogą zostać wysłane: rozpoczęte o (linia 12)”, @session_start()w tym przypadku nadal się nie powiedzie, ale komunikat o błędzie nie jest drukowany na ekran.

Przed dołączeniem plików lub przekierowaniem na nową stronę skorzystaj z exit()funkcji, w przeciwnym razie pojawi się błąd.

Tego kodu można użyć we wszystkich przypadkach:

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

W PHP 5.3 to działa dla mnie:

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

to masz. Jeśli nie umieścisz instrukcji „if” na początku, sesja rozpocznie się w jakikolwiek sposób, nie wiem dlaczego.

Odpowiedź OPARTA na odpowiedzi @Meliza Ramos (patrz pierwsza odpowiedź) i http://php.net/manual/en/function.phpversion.php ,

DZIAŁANIA:

• zdefiniuj PHP_VERSION_ID, jeśli nie istnieje
• zdefiniuj funkcję sprawdzania wersji na podstawie PHP_VERSION_ID
• Zdefiniuj funkcję bezpieczną dla openSession ()

używaj tylko 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();
    }
}

Właściwie jest już za późno, aby wyjaśnić to tutaj, ponieważ zostało rozwiązane. To był plik .inc jednego z moich projektów, w którym konfigurujesz menu restauracji, wybierając danie i usuwając / dodając lub zmieniając kolejność. Serwer, na którym pracowałem, nie miał rzeczywistej wersji, więc uczyniłem ją bardziej elastyczną. To zależy od autorów, którzy chcą go wykorzystać i wypróbować.

Czy ten fragment kodu działa dla Ciebie?

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

Powinieneś zreorganizować swój kod, aby wywoływać session_start()dokładnie raz na wykonanie strony.

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

Wersja PHP_VERSION_ID jest dostępna od wersji PHP 5.2.7, więc sprawdź to najpierw i, jeśli to konieczne, utwórz ją. session_statusjest dostępny od PHP 5.4, dlatego też musimy to sprawdzić:

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

Opierając się na mojej praktyce, przed uzyskaniem dostępu do $_SESSION[]musisz zadzwonić za session_startkażdym razem, aby użyć skryptu. Zobacz poniższy link do instrukcji.

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

Dla mnie przynajmniej session_startjest mylące jako nazwa. A session_loadmoże być bardziej jasne.

skończyłem z podwójną kontrolą statusu. php 5.4+

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

Możesz użyć następującego rozwiązania, aby sprawdzić, czy sesja PHP już się rozpoczęła:

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

Właśnie tego używam do ustalenia, czy sesja się rozpoczęła. Używając pustego i isset w następujący sposób:

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

Zamień na session_start();:

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