Vérifier si PHP la session a déjà commencé
J'ai un fichier PHP qui est parfois appelé à partir d'une page qui a démarré une session et parfois d'une page qui n'a pas démarré de session. Par conséquent, lorsque j'ai session_start() sur ce script, le message d'erreur "session déjà commencée" s'affiche parfois. Pour cela j'ai mis ces lignes:
if(!isset($_COOKIE["PHPSESSID"]))
{
session_start();
}
mais cette fois j'ai eu ce message d'avertissement:
Avis: 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, les choses fonctionneront-elles correctement et les avertissements seront-ils fermés?
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/fr/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
}
Bien que, à mon humble avis, vous devriez vraiment penser à refactoriser votre code de gestion de session si vous ne savez pas si une session est démarré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 est commencée.
PHP 5.4 introduit session_status () , qui est plus fiable que de s'appuyer sur session_id().
Considérez l'extrait 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 dans PHP 5.4 est la suivante:
session_status() == PHP_SESSION_ACTIVE
vous pouvez le faire, et c'est vraiment facile.
if (!isset($_SESSION)) session_start();
J'espère que ça aide :)
Avant PHP 5.4, il n’existait aucun moyen fiable de connaître autre chose 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.
Ainsi, avant PHP 5.4, vous devriez définir un booléen global.
if (version_compare(phpversion(), '5.4.0', '<')) {
if(session_id() == '') {
session_start();
}
}
else
{
if (session_status() == PHP_SESSION_NONE) {
session_start();
}
}
Pour toute version php
if ((function_exists('session_status')
&& session_status() !== PHP_SESSION_ACTIVE) || !session_id()) {
session_start();
}
Vérifie ç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 renvoie 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();
}
Cela devrait fonctionner pour toutes les versions PHP. Il détermine la version PHP, puis vérifie si la session est démarrée sur la base de la version PHP. Ensuite, si la session n’est pas lancée, elle commence.
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(); }
j'espère que ça aide !
La seule chose à faire est de:
<?php
if(!isset($_SESSION))
{
session_start();
}
?>
Pas sûr de l'efficacité d'une telle solution, mais cela provient d'un projet fonctionnel 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 qu'un appel de fonction ne supprime les erreurs pouvant être signalées pendant l'appel de fonction.
L'ajout d'un @ avant session_start indique à PHP d'éviter l'impression des messages d'erreur.
Par exemple:
Utiliser session_start() après avoir déjà imprimé quelque chose dans le navigateur génère une erreur. Ainsi, PHP affichera quelque chose du type "les en-têtes ne peuvent pas être envoyés: démarré à (ligne 12)", @session_start() échouera dans ce cas, mais le message d'erreur n'est pas imprimé à l'écran.
Avant d'inclure les fichiers ou de rediriger vers une nouvelle page, utilisez la fonction exit(), sinon une erreur se produira.
Ce code peut être utilisé dans tous les cas:
<?php
if (session_status() !== PHP_SESSION_ACTIVE || session_id() === ""){
session_start();
}
?>
Vous devez réorganiser votre code afin d'appeler session_start() une seule fois par exécution de page.
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 car il a été résolu . C’était un fichier .inc de l’un de mes projets où vous configurez un menu pour un restaurant en sélectionnant un plat et en supprimant/ajoutant order . Le serveur sur lequel je travaillais n’avait pas la version réelle, je l’ai donc rendu plus flexible. C'est aux auteurs qui le souhaitent de l'utiliser et de l'essayer.
Cet extrait de code fonctionne-t-il pour vous?
if (!count($_SESSION)>0) {
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 la déclaration pas à si début, la session commencera de quelque manière que ce soit, je ne sais pas pourquoi.
Response BASE sur @ Meliza Ramos Response (voir première réponse) et http://php.net/manual/en/function.phpversion.php
ACTES:
- 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 une fonction pour openSession () secure
utilisez seulement 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();
}
}
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";
}
session_start();
if(!empty($_SESSION['user']))
{
//code;
}
else
{
header("location:index.php");
}
C'est ce que j'utilise pour déterminer si une session a démarré. En utilisant empty et isset comme suit:
if (empty($_SESSION) && !isset($_SESSION)) {
session_start();
}
je me suis retrouvé avec une double vérification du statut. php 5.4+
if(session_status() !== PHP_SESSION_ACTIVE){session_start();};
if(session_status() !== PHP_SESSION_ACTIVE){die('session start failed');};
Selon ma pratique, avant d'accéder au $_SESSION[], vous devez appeler session_start à chaque 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_start est déroutant en tant que nom. Un session_load peut être plus clair.
PHP_VERSION_ID est disponible à partir de PHP 5.2.7, vérifiez donc ceci en premier et créez-le si nécessaire. session_status est 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();
}
}