> Gérer les sessions en PHP : session_start, la superglobale $_SESSION, stocker et lire des données, déconnexion, sécurité avec session_regenerate_id. Le guide complet avec du code réel.

*Source : https://coder-studio.com/tutoriels/sessions-php/*

---

[// PHP](https://coder-studio.com/tutoriels/)

# Les sessions en PHP : gérer l'état utilisateur

Par **Kévin Papot** · publié le 18 février 2026

**La session en PHP** répond à un problème fondamental du web : HTTP est un protocole sans mémoire. Chaque requête est indépendante, le serveur « oublie » l’utilisateur d’une page à l’autre. Comment, alors, garder un internaute connecté, mémoriser son panier ou sa langue ? La réponse s’appelle la session. Elle stocke des données côté serveur, associées à un identifiant unique déposé dans le navigateur. Ce guide couvre tout ce qu’il faut savoir pour l’utiliser correctement et en sécurité.

## Démarrer une session avec session\_start

Tout commence par `session_start()`. Cette fonction doit être appelée **avant tout affichage** (avant le moindre `echo` ou espace dans le HTML), sous peine d’erreur « headers already sent ».

```
<?php
session_start(); // Toujours en tout premier

// À partir d'ici, $_SESSION est disponible
```

Au premier appel, PHP génère un identifiant de session unique et l’envoie au navigateur sous forme de cookie (`PHPSESSID` par défaut). À chaque requête suivante, le navigateur renvoie ce cookie, et PHP retrouve automatiquement les données associées.

## Stocker des données dans $\_SESSION

La superglobale `$_SESSION` est un simple tableau associatif. Vous y écrivez ce que vous voulez.

```
<?php
session_start();

$_SESSION["utilisateur_id"] = 42;
$_SESSION["pseudo"]         = "Léa";
$_SESSION["role"]           = "admin";

// On peut y stocker un tableau entier
$_SESSION["panier"] = [
    ["produit" => "Clavier", "prix" => 49.90],
    ["produit" => "Souris",  "prix" => 24.90],
];
```

Ces données persistent tant que la session reste active, d’une page à l’autre, sans que vous ayez à les repasser en paramètre.

## Lire les données de session

Sur n’importe quelle autre page, il suffit de rappeler `session_start()` pour retrouver le contenu.

```
<?php
session_start();

// Toujours vérifier l'existence avant de lire
if (isset($_SESSION["pseudo"])) {
    echo "Bonjour " . htmlspecialchars($_SESSION["pseudo"]);
} else {
    echo "Visiteur non connecté";
}
```

Le réflexe `isset()` évite les avertissements sur une clé absente. Et `htmlspecialchars()` est indispensable dès que vous affichez une donnée pour vous prémunir contre les failles XSS.

### Vérifier si un utilisateur est connecté

Le cas d’usage le plus fréquent : protéger une page réservée aux membres.

```
<?php
session_start();

if (!isset($_SESSION["utilisateur_id"])) {
    header("Location: /connexion.php");
    exit; // Toujours exit après une redirection
}

// Le reste de la page ne s'exécute que pour un utilisateur connecté
```

## Supprimer une donnée précise

Pour retirer une seule variable de session sans toucher au reste, utilisez `unset()`.

```
<?php
session_start();

unset($_SESSION["panier"]); // Vide uniquement le panier

// Le pseudo et l'id de l'utilisateur restent intacts
```

## Détruire la session : la déconnexion

Fermer une session (logout) demande plus qu’un simple `unset`. Il faut vider les données, invalider le cookie, puis détruire la session côté serveur. Voici la procédure complète et recommandée.

```
<?php
session_start();

// 1. Vider le tableau de session
$_SESSION = [];

// 2. Supprimer le cookie de session côté navigateur
if (ini_get("session.use_cookies")) {
    $params = session_get_cookie_params();
    setcookie(
        session_name(),
        "",
        time() - 42000,
        $params["path"],
        $params["domain"],
        $params["secure"],
        $params["httponly"]
    );
}

// 3. Détruire la session côté serveur
session_destroy();

// 4. Rediriger
header("Location: /connexion.php");
exit;
```

Les trois étapes sont importantes : `$_SESSION = []` vide la mémoire de la requête courante, le `setcookie` expiré nettoie le navigateur, et `session_destroy()` efface le fichier de session sur le serveur.

## Sécuriser ses sessions

Une session mal protégée est une porte ouverte au détournement de compte. Quelques mesures simples renforcent nettement la sécurité.

### Régénérer l’identifiant de session

Après une connexion réussie, changez l’identifiant de session avec `session_regenerate_id()`. Cela contre les attaques par **fixation de session**, où un attaquant impose un identifiant connu à la victime.

```
<?php
session_start();

// Après vérification réussie du mot de passe :
session_regenerate_id(true); // true = supprime l'ancien fichier de session
$_SESSION["utilisateur_id"] = $utilisateur["id"];
```

### Configurer des cookies de session sûrs

Idéalement avant `session_start()`, imposez des cookies de session robustes.

```
<?php
session_set_cookie_params([
    "lifetime" => 0,          // expire à la fermeture du navigateur
    "path"     => "/",
    "secure"   => true,       // uniquement en HTTPS
    "httponly" => true,       // inaccessible au JavaScript (anti-XSS)
    "samesite" => "Strict",   // limite les requêtes cross-site (anti-CSRF)
]);
session_start();
```

L’option `httponly` empêche un script JavaScript malveillant de lire le cookie de session, et `samesite` réduit le risque d’attaque CSRF. Ces deux réglages devraient être systématiques.

### Limiter la durée de vie

Pour une session sensible, vérifiez l’inactivité et forcez une reconnexion au bout d’un certain temps.

```
<?php
session_start();

$delaiMax = 1800; // 30 minutes

if (isset($_SESSION["derniere_activite"])
    && (time() - $_SESSION["derniere_activite"] > $delaiMax)) {
    session_unset();
    session_destroy();
    header("Location: /connexion.php?expiree=1");
    exit;
}
$_SESSION["derniere_activite"] = time();
```

## Sessions vs cookies : quelle différence ?

On confond souvent les deux, alors qu’ils jouent des rôles complémentaires.

-   **Le cookie** stocke les données **côté navigateur**. Il est visible et modifiable par l’utilisateur, limité en taille (environ 4 Ko) et voyage à chaque requête. Idéal pour des préférences non sensibles ou un « se souvenir de moi ».
-   **La session** stocke les données **côté serveur**. Seul l’identifiant transite via un cookie. L’utilisateur ne voit jamais le contenu, ce qui la rend adaptée aux données sensibles : identité, droits, panier.

En clair : ne mettez jamais un `role => admin` dans un cookie brut, un utilisateur pourrait le modifier. Placez-le dans la session, dont seul le serveur détient le contenu. Pour aller plus loin sur la manipulation des données que vous stockerez en session, notre guide sur [les tableaux en PHP](https://coder-studio.com/tutoriels/tableaux-php/) est un bon complément.

## En résumé

La session est le mécanisme standard pour garder un état d’un utilisateur en PHP. Retenez la mécanique : `session_start()` en tête de fichier, `$_SESSION` comme tableau de stockage, `unset()` pour retirer une donnée, et la procédure complète de destruction pour la déconnexion. Côté sécurité, trois réflexes suffisent à éviter l’essentiel des problèmes : `session_regenerate_id()` après connexion, cookies `httponly` + `secure` + `samesite`, et une expiration par inactivité. Avec ça, vous gérez l’authentification de vos applications sur des bases solides.

## À lire ensuite

-   [PHP : le guide pour bien débuter](https://coder-studio.com/tutoriels/php-guide-debutant/)
-   [Les tableaux en PHP : indexés, associatifs et fonctions utiles](https://coder-studio.com/tutoriels/tableaux-php/)
-   [Symfony : découvrir le framework PHP de référence](https://coder-studio.com/tutoriels/symfony-framework-php/)