Verifique se a sessão PHP já foi iniciada

461

Eu tenho um arquivo PHP que às vezes é chamado de uma página que iniciou uma sessão e, às vezes, de uma página que não iniciou a sessão. Portanto, quando tenho session_start()esse script, às vezes recebo a mensagem de erro para "sessão já iniciada". Para isso eu coloquei estas linhas:

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

mas desta vez recebi esta mensagem de aviso:

Aviso: Variável indefinida: _SESSION

Existe uma maneira melhor de verificar se a sessão já começou?

Se eu usar @session_start, isso fará as coisas funcionarem corretamente e calar a boca os avisos?

Logan
fonte
2
possível duplicata de como verifico se session_start foi inserido?
Richard Harrison
Consulte também estas respostas do Stackoverflow: stackoverflow.com/questions/1545357/…
contact-form.co_you_go 4/15/17

Respostas:

761

Maneira recomendada para versões do PHP> = 5.4.0, PHP 7

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

Referência: http://www.php.net/manual/en/function.session-status.php

Para versões do PHP <5.4.0

if(session_id() == '') {
    session_start();
}
lovelyramos
fonte
1
Eu acho que há um problema com a solução para PHP <5.4. session_id é definido como a PRIMEIRA vez em que a sessão é iniciada, mas não é excluída quando a sessão é fechada. Assim, por exemplo, se houver, antes do seu trecho, um código como session_start();session_write_close();: a condição if falhará, mas não teremos uma sessão aberta ...
Nicolò Martini 15/05
@ Nicolo Martini Pelo que entendi: uma sessão iniciada com session_start()a parte superior de um script é FECHADA quando o script sai, OU quando session_write_closed()é chamada antes da saída do script. Ou seja, uma sessão FECHA quando seus dados são gravados no cookie da sessão e a sessão é desbloqueada para acesso por outro script que também chama 'session_start'. FECHAR NÃO significa que a sessão está DESTRUÍDA, portanto. Você pode fechar uma sessão saindo do script ou da chamada atual session_write_close()e pode abri-la novamente chamando session_start(). Meu entendimento, pelo menos.
Stefan
1
Ainda é uma boa maneira de iniciar uma sessão? Porque no link não há nada relacionado a esta resposta
csandreas1
@ csandreas1, você verá no link a descrição do session_status e seus valores de retorno esperados. A resposta para sua pergunta é sim!
LovelyRemr
Eu já tive essa falha em algumas circunstâncias - usei if (! Isset ($ _ SESSION)) com sucesso
Scott
161

Para versões do PHP anteriores ao PHP 5.4.0:

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

No entanto, IMHO, você deve realmente pensar em refatorar seu código de gerenciamento de sessões se não souber se uma sessão foi iniciada ou não ...

Dito isso, minha opinião é subjetiva e há situações (exemplos dos quais são descritos nos comentários abaixo) em que talvez não seja possível saber se a sessão foi iniciada.

Alex
fonte
37
Não é necessariamente ruim não saber se sua sessão foi iniciada. Se você estiver carregando preguiçosamente (apenas iniciando a sessão quando for necessário), o teste em sua resposta seria perfeitamente adequado.
drewm
1
Também em alguns ambientes apache tem autostarting sessão configurar
LeonardChallis
Um exemplo para testar se session_id () retorna uma string vazia em um arquivo de inclusão:
tgoneil 5/05
3
O comentário sobre o gerenciamento de sessões de refatoração, se você não souber se é torto ou não, não é realmente relevante. Por exemplo, ao codificar recursos avançados em um tema WordPress, você nunca saberá se um plug-in já começou a usar sessões sem verificar. O mundo da codificação nem sempre é preto e branco: P
Jimbo Jonny
Mmm, bons pontos, de fato. Eu admito que meus comentários são muito subjetivos - vou alterar minha resposta para refletir isso.
8283 Alex
71

O PHP 5.4 introduziu session_status () , que é mais confiável do que confiar emsession_id() .

Considere o seguinte trecho:

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

Portanto, para verificar se uma sessão foi iniciada, a maneira recomendada no PHP 5.4 é agora:

session_status() == PHP_SESSION_ACTIVE
Benjamin
fonte
3
Um trecho de código que utiliza session_status quando disponível e métodos mais antigos, quando não parece ser perfeito aqui BTW, dica dica :)
Jimbo Jonny
1
Obrigado pela atualização Benjamin. É bom saber que um novo método pode ser usado a partir do PHP 5.4.
Logan
1
Esta é uma maneira muito melhor de verificar isso, você nem sempre sabe se a sessão foi iniciada, especialmente quando o usuário limpa os cookies quando eles estão no meio da navegação no site ... Eu sempre codigo para crianças de 2 anos, você nunca sei o que os usuários farão ;-) Quanto a mim, tenho um pequeno arquivo Config.php que é chamado em todos os meus scripts para configurar variáveis ​​e outras informações; portanto, basta adicionar isso nesse arquivo para garantir que a sessão seja iniciada se ela é necessária
Andy Braham
35

você pode fazer isso e é realmente fácil.

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

Espero que ajude :)

miyuru
fonte
6
@ zloctb: Eu não consigo pensar em nenhuma situação em que eu faria $_SESSION=array();, então essa resposta parece boa.
Halfer 19/10
5
@halfer Veja a resposta de Ryan. Se session_destroy()tiver sido chamado, $_SESSIONainda poderá ser definido. Além disso, nos testes de unidade, você pode definir $_SESSIONdiretamente. Mas eu upvoted isso, como para a maioria das situações práticas esta resposta deve ser bom o suficiente (até PHP 5.3 é visto nunca mais ...)
Darren Cozinhe
22
if (version_compare(phpversion(), '5.4.0', '<')) {
     if(session_id() == '') {
        session_start();
     }
 }
 else
 {
    if (session_status() == PHP_SESSION_NONE) {
        session_start();
    }
 }
k.bon
fonte
21

Antes do PHP 5.4, não havia maneira confiável de saber além de definir uma bandeira global.

Considerar:

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.

Portanto, antes do PHP 5.4, você deve definir um booleano global.

RY
fonte
12

Para toda a versão php

if ((function_exists('session_status') 
  && session_status() !== PHP_SESSION_ACTIVE) || !session_id()) {
  session_start();
}
supersuphot
fonte
1
Da mesma forma, alguém poderia fazer o mesmo #if ((defined('PHP_SESSION_ACTIVE') && session_status() !== PHP_SESSION_ACTIVE) || !session_id())
Anthony Hatzopoulos 26/11
9

Verifique isto:

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

Fonte http://php.net

Elshan
fonte
6

Use session_id () , ele retornará uma string vazia se não estiver definida. É mais confiável do que verificar o $_COOKIE.

if (strlen(session_id()) < 1) {
    session_start();
}
Wesley van Opdorp
fonte
5
if (session_id() === "") { session_start(); }

espero que ajude !

Mahesh Cheliya
fonte
5

Isso deve funcionar para todas as versões do PHP. Ele determina a versão do PHP e verifica se a sessão é iniciada com base na versão do PHP. Se a sessão não for iniciada, ela será iniciada.

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();
    }
  }
}
Dustin Poissant
fonte
4

A única coisa que você precisa fazer é:

<?php
if(!isset($_SESSION))
{
session_start();
}
?>
user3140580
fonte
Este é o que eu usei ao longo dos anos. Alguém avisando para não usar este? É claro que é bom usar uma verificação se a sessão for iniciada algumas vezes - em alguns ambientes, o apache possui inicialização automática da sessão configurada, carregamento lento (apenas iniciando a sessão quando for necessário) ou simplesmente que às vezes é necessário fazer um hack rápido
K Kilian Lindberg,
É a mesma resposta acima (@miyuru)
2

Não tenho certeza sobre a eficiência dessa solução, mas isso é do projeto de trabalho. Isso também é usado se você precisar definir o idioma padrão.

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

@ antes de uma chamada de função suprime quaisquer erros que possam ser relatados durante a chamada de função.

Adicionando um @antessession_start diz ao PHP para evitar a impressão de mensagens de erro.

Por exemplo:

O uso session_start()após a impressão de algo no navegador resulta em um erro, portanto o PHP exibirá algo como "cabeçalhos não podem ser enviados: iniciado em (linha 12)",@session_start() ainda falhará nesse caso, mas a mensagem de erro não é impressa em tela.

Antes de incluir os arquivos ou redirecionar para a nova página, use o exit() função, caso contrário, ocorrerá um erro.

Este código pode ser usado em todos os casos:


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

No PHP 5.3, isso funciona para mim:

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

então você tem. Se você não colocar a declaração not at if começando a sessão, de qualquer maneira, não sei por quê.

Lucas M. Oliveira
fonte
1

Resposta BASEADA na resposta de Meliza Ramos (consulte a primeira resposta) e http://php.net/manual/en/function.phpversion.php ,

AÇÕES:

  • defina PHP_VERSION_ID se não existir
  • define a função para verificar a versão com base em PHP_VERSION_ID
  • defina a função para openSession () secure

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

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

Na verdade, agora é tarde demais para explicá-lo aqui de qualquer maneira, pois foi resolvido. Este foi um arquivo .inc de um dos meus projetos em que você configura um menu para um restaurante selecionando um prato e removendo / adicionando ou alterando a ordem. O servidor em que eu estava trabalhando não tinha a versão real, então a tornei mais flexível. Cabe aos autores que desejam usá-lo e experimentá-lo.

Thielicious
fonte
1

Este snippet de código funciona para você?

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

Você deve reorganizar seu código para ligar session_start()exatamente uma vez por execução da página.

SamT
fonte
4
chamá-lo exatamente uma vez por execução de página pode não ser desejado em algumas situações.
Timo Huovinen
Se você está matando a sessão para recriá-la, com certeza, mas esse é um caso especial. Em geral, o aplicativo deve ter o código que é executado logo no início, e é para onde vai o session_start ().
SAMT
1
por exemplo, um aplicativo armazena sessões em um arquivo e precisa carregar 2 solicitações lentas simultâneas de dados, nenhuma dessas solicitações precisa de sessões, mas uma bloqueará a outra porque session_start bloqueia o arquivo da sessão.
Timo Huovinen
Exatamente. @YuriKolovsky está certo. A pergunta de Alex é pertinente porque esses casos podem ocorrer e não são incomuns.
Paulo Coghi - Restabelece Monica
14
-1, a maioria dos sites é dirigida por CMS e possui itens como temas e plug-ins, geralmente escritos por diferentes partes, sem saber se o código um do outro iniciou sessões ou não. A implicação de que este é apenas um problema de organização de código é falsa.
Jimbo Jonny
0
session_start();
if(!empty($_SESSION['user']))
{     
  //code;
}
else
{
    header("location:index.php");
}
Sukanya Suku
fonte
0

PHP_VERSION_ID está disponível a partir do PHP 5.2.7, portanto, verifique isso primeiro e, se necessário, crie-o. session_statusestá disponível a partir do PHP 5.4, então precisamos verificar isso também:

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();
    }
}
Christian Kruse
fonte
0

Com base na minha prática, antes de acessar o que $_SESSION[]você precisa chamarsession_start sempre para usar o script. Veja o link abaixo para o manual.

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

Para mim, pelo menos, session_starté confuso como um nome. A session_loadpode ser mais claro.

Eduard Hasanaj
fonte
0

acabei com uma verificação dupla de status. php 5.4+

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

Você pode usar a seguinte solução para verificar se uma sessão PHP já foi iniciada:

if(session_id()== '')
{
   echo"Session isn't Start";
}
else
{
    echo"Session Started";
}
Manjeet Kumar Nai
fonte
A resposta válida é mais detalhada.
Clément Prévost
0

É isso que eu uso para determinar se uma sessão foi iniciada. Usando vazio e isset da seguinte maneira:

if (empty($_SESSION)  && !isset($_SESSION))  {
    session_start();
}
Rotimi
fonte
-3

Substitua session_start();por:

if (!isset($a)) {
    a = False;
    if ($a == TRUE) {
        session_start();
        $a = TRUE;
    }
}
Harshit Chaturvedi
fonte
ele contém erros de código e só funcionaria se o mesmo arquivo fosse incluído várias vezes, mas não se estivesse dentro de um fechamento.
precisa saber é o seguinte