PHP Global Variable : comprendre les variables globales, $GLOBALS, global et les superglobales

Une global variable en PHP désigne une variable déclarée dans la portée globale d’un script, généralement en dehors d’une fonction. Elle reste directement accessible dans cette portée, mais PHP applique une règle essentielle : une fonction ne peut pas utiliser automatiquement les variables globales définies à l’extérieur de son propre scope.

Pour accéder à une variable globale depuis une fonction PHP, plusieurs mécanismes existent. Le mot-clé global permet d’importer une référence vers la variable globale dans la portée locale de la fonction, tandis que le tableau superglobal $GLOBALS donne accès aux variables définies dans l’espace global. PHP fournit également plusieurs variables dites superglobales, comme $_GET, $_POST, $_SESSION, $_SERVER ou $_COOKIE, accessibles depuis toutes les portées du script.

Comprendre ces mécanismes permet d’éviter des erreurs fréquentes : variable indéfinie dans une fonction, confusion entre variable globale et superglobale, modification involontaire d’une donnée partagée ou dépendances difficiles à suivre dans une application PHP.

Qu’est-ce qu’une variable globale en PHP ?

Une variable déclarée en dehors d’une fonction appartient à la portée globale du script.

Exemple :

<?php

$siteName = 'Le Cours Gratuit';

echo $siteName;

La variable $siteName est globale parce qu’elle est définie dans la portée principale du fichier.

Elle peut être utilisée directement plus loin dans cette même portée :

<?php

$prix = 100;

$taxe = 20;

$total = $prix + $taxe;

echo $total;

Le résultat est :

120

La situation change dès qu’une fonction intervient.

Une variable globale PHP est-elle accessible dans une fonction ?

Considérons :

<?php

$prix = 100;

function afficherPrix()
{
    echo $prix;
}

afficherPrix();

Ce code ne permet pas d’utiliser automatiquement $prix dans la fonction.

La variable appartient à la portée globale, alors que la fonction possède sa propre portée locale.

On peut représenter la séparation ainsi :

PORTÉE GLOBALE

$prix = 100
     │
     │ pas automatiquement visible
     ▼
┌──────────────────────────┐
│ function afficherPrix()  │
│                          │
│ Portée locale            │
└──────────────────────────┘

Cette isolation réduit les interactions implicites entre les différentes parties du programme.

Utiliser le mot-clé global en PHP

PHP fournit le mot-clé global pour accéder à une variable globale depuis une fonction.

<?php

$prix = 100;

function afficherPrix()
{
    global $prix;

    echo $prix;
}

afficherPrix();

Résultat :

100

La déclaration :

global $prix;

rend la variable globale $prix accessible sous ce nom dans la fonction.

Modifier une variable globale avec global

La fonction peut également modifier sa valeur :

<?php

$compteur = 0;

function incrementer()
{
    global $compteur;

    $compteur++;
}

incrementer();
incrementer();
incrementer();

echo $compteur;

Résultat :

3

La fonction travaille ici sur la variable globale elle-même.

Utiliser plusieurs variables globales dans une fonction PHP

Plusieurs variables peuvent être déclarées avec global :

<?php

$prix = 100;
$tauxTVA = 0.20;

function calculerTTC()
{
    global $prix, $tauxTVA;

    return $prix * (1 + $tauxTVA);
}

echo calculerTTC();

Résultat :

120

La syntaxe est concise :

global $prix, $tauxTVA;

Elle crée néanmoins une dépendance entre la fonction et l’état global du programme.

$GLOBALS en PHP : accéder aux variables globales

PHP met à disposition le tableau superglobal $GLOBALS.

Il contient les variables disponibles dans la portée globale.

Exemple :

<?php

$message = 'Bonjour';

function afficherMessage()
{
    echo $GLOBALS['message'];
}

afficherMessage();

Résultat :

Bonjour

Ici, aucun mot-clé global n’est nécessaire.

Modifier une variable avec $GLOBALS

Une fonction peut également changer la valeur globale :

<?php

$stock = 10;

function ajouterStock()
{
    $GLOBALS['stock'] += 5;
}

ajouterStock();

echo $stock;

Résultat :

15

$GLOBALS['stock'] désigne ici la variable globale $stock.

global ou $GLOBALS : quelle différence ?

Les deux mécanismes permettent d’accéder à l’état global depuis une fonction, mais leur écriture diffère.

Avec global :

function afficherPrix()
{
    global $prix;

    echo $prix;
}

Avec $GLOBALS :

function afficherPrix()
{
    echo $GLOBALS['prix'];
}

La seconde syntaxe rend immédiatement visible le caractère global de la donnée.

Pour du code applicatif réutilisable, transmettre explicitement les données en paramètres reste souvent plus clair.

Variable globale ou paramètre de fonction ?

Comparons deux approches.

Avec une variable globale

<?php

$taux = 0.20;

function calculerTaxe($montant)
{
    global $taux;

    return $montant * $taux;
}

echo calculerTaxe(100);

La fonction dépend implicitement de $taux.

Avec un paramètre

<?php

function calculerTaxe(
    float $montant,
    float $taux
): float {
    return $montant * $taux;
}

echo calculerTaxe(100, 0.20);

La dépendance apparaît directement dans la signature :

calculerTaxe($montant, $taux)

Cette approche facilite la lecture, les tests et la réutilisation.

Par exemple :

echo calculerTaxe(100, 0.20);
echo calculerTaxe(100, 0.055);
echo calculerTaxe(250, 0.10);

La fonction fonctionne avec plusieurs taux sans dépendre d’une configuration globale cachée.

Qu’est-ce qu’une variable superglobale en PHP ?

Une superglobale PHP est une variable prédéfinie accessible dans toutes les portées du script, y compris à l’intérieur des fonctions, sans utiliser global.

Les principales superglobales PHP sont :

Ces variables répondent à des besoins très différents.

Exemple avec $_GET

Une URL peut contenir :

produit.php?id=42

PHP récupère la valeur avec :

<?php

$id = $_GET['id'] ?? null;

Une validation est ensuite nécessaire :

<?php

$id = filter_input(
    INPUT_GET,
    'id',
    FILTER_VALIDATE_INT
);

if ($id === false || $id === null) {
    echo 'Identifiant invalide.';
    exit;
}

echo 'Produit : ' . $id;

Exemple avec $_POST

Pour un formulaire :

<form method="post">
    <label for="nom">Nom</label>

    <input
        type="text"
        id="nom"
        name="nom"
        required
    >

    <button type="submit">
        Envoyer
    </button>
</form>

PHP récupère :

<?php

$nom = trim(
    (string) ($_POST['nom'] ?? '')
);

if ($nom !== '') {
    echo htmlspecialchars(
        $nom,
        ENT_QUOTES,
        'UTF-8'
    );
}

$_POST est accessible à l’intérieur d’une fonction sans déclaration global :

<?php

function recupererNom(): string
{
    return trim(
        (string) ($_POST['nom'] ?? '')
    );
}

C’est précisément ce qui distingue une superglobale d’une simple variable globale.

Variable globale PHP et $_SESSION : quelle différence ?

Les deux notions sont parfois confondues.

Une variable globale :

$utilisateur = 'Alice';

existe pendant l’exécution de la requête PHP concernée.

Une variable de session :

$_SESSION['utilisateur'] = 'Alice';

peut être conservée entre plusieurs requêtes du même utilisateur, à condition d’utiliser correctement les sessions PHP.

Exemple :

<?php

session_start();

$_SESSION['utilisateur'] = 'Alice';

Sur une autre page :

<?php

session_start();

echo $_SESSION['utilisateur'] ?? 'Visiteur';

$_SESSION répond donc à un problème de persistance entre les requêtes, tandis qu’une variable globale classique concerne principalement la portée d’exécution du script.

Une variable globale PHP est-elle conservée entre deux pages ?

Non.

Considérons page1.php :

<?php

$score = 100;

Puis page2.php :

<?php

echo $score;

page2.php ne récupère pas automatiquement la variable de page1.php.

HTTP fonctionne par requêtes distinctes.

Pour conserver une donnée entre plusieurs pages, plusieurs solutions existent :

• session PHP ;
• cookie ;
• base de données ;
• cache ;
• fichier ;
• paramètres GET ou POST ;
• stockage externe.

Le choix dépend de la durée de conservation, du niveau de sécurité et de la nature de la donnée.

Variable globale PHP entre plusieurs fichiers

Le comportement est différent lorsque plusieurs fichiers participent à la même requête grâce à include ou require.

config.php

<?php

$nomApplication = 'Mon Application';

index.php

<?php

require 'config.php';

echo $nomApplication;

La variable devient disponible parce que config.php est exécuté dans le contexte de la requête courante.

Une fonction conserve toutefois sa propre portée :

<?php

require 'config.php';

function afficherNom()
{
    global $nomApplication;

    echo $nomApplication;
}

afficherNom();

Variable globale et fichier de configuration PHP

Les petits projets utilisent parfois des variables globales pour la configuration :

<?php

$dbHost = 'localhost';
$dbName = 'boutique';
$dbPort = 3306;

Une structure explicite est généralement plus facile à manipuler :

<?php

$config = [
    'database' => [
        'host' => 'localhost',
        'name' => 'boutique',
        'port' => 3306
    ]
];

Puis :

echo $config['database']['host'];

Une autre approche consiste à retourner directement la configuration depuis le fichier.

config.php

<?php

return [
    'database' => [
        'host' => 'localhost',
        'name' => 'boutique',
        'port' => 3306
    ]
];

index.php

<?php

$config = require 'config.php';

echo $config['database']['name'];

Cette organisation réduit le recours aux variables globales dispersées.

Variable globale et variable statique PHP

Une variable static à l’intérieur d’une fonction ne doit pas être confondue avec une variable globale.

<?php

function compteur(): int
{
    static $nombre = 0;

    $nombre++;

    return $nombre;
}

echo compteur();
echo compteur();
echo compteur();

Résultat :

123

$nombre reste locale à la fonction, mais sa valeur est conservée entre plusieurs appels de cette fonction pendant l’exécution.

Comparaison :

Variable globale dans une fonction anonyme PHP

Les fonctions anonymes disposent également de leur propre portée.

Exemple :

<?php

$message = 'Bonjour';

$afficher = function () use ($message) {
    echo $message;
};

$afficher();

Le mot-clé use importe ici la valeur dans la closure.

Modifier une variable externe depuis une closure

Une référence peut être utilisée :

<?php

$compteur = 0;

$incrementer = function () use (&$compteur) {
    $compteur++;
};

$incrementer();
$incrementer();

echo $compteur;

Résultat :

2

Le symbole & permet à la closure de travailler sur la variable externe elle-même.

Cette technique ne correspond pas au mot-clé global : elle capture explicitement une variable du scope englobant.

Variable globale dans une classe PHP

Les classes offrent des mécanismes plus structurés pour conserver un état.

Plutôt que :

<?php

$tauxTVA = 0.20;

function calculerPrixTTC($prix)
{
    global $tauxTVA;

    return $prix * (1 + $tauxTVA);
}

on peut encapsuler le taux :

<?php

class CalculateurPrix
{
    public function __construct(
        private float $tauxTVA
    ) {
    }

    public function calculerTTC(
        float $prix
    ): float {
        return $prix * (1 + $this->tauxTVA);
    }
}

$calculateur = new CalculateurPrix(0.20);

echo $calculateur->calculerTTC(100);

La dépendance devient explicite et appartient à l’objet.

Cette architecture prend davantage de sens lorsque l’application grandit ou que la même logique doit être testée et réutilisée.

Variables globales et constantes PHP

Une valeur qui ne doit pas changer peut parfois être représentée par une constante plutôt que par une variable globale mutable.

Exemple :

<?php

const TVA_STANDARD = 0.20;

function calculerTTC(float $prix): float
{
    return $prix * (1 + TVA_STANDARD);
}

Pour certaines configurations immuables, cette solution exprime mieux l’intention du code.

Les constantes ne remplacent cependant pas toutes les variables globales : leur rôle convient surtout aux valeurs qui ne doivent pas être réaffectées pendant l’exécution.

Modifier une variable globale PHP avec JavaScript

JavaScript ne peut pas modifier directement une variable globale PHP déjà exécutée sur le serveur.

Exemple :

<?php

$score = 10;
?>

<script>
let score = 20;
</script>

La variable JavaScript score et la variable PHP $score sont indépendantes.

Pour envoyer la nouvelle valeur au serveur, JavaScript peut utiliser Fetch :

fetch('modifier-score.php', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json',
        'Accept': 'application/json'
    },
    body: JSON.stringify({
        score: 20
    })
});

PHP reçoit ensuite la nouvelle donnée :

<?php

$donnees = json_decode(
    file_get_contents('php://input'),
    true
);

$score = filter_var(
    $donnees['score'] ?? null,
    FILTER_VALIDATE_INT
);

if ($score === false) {
    http_response_code(422);
    exit;
}

Pour conserver cette valeur entre plusieurs requêtes, PHP doit ensuite utiliser une session, une base de données ou un autre système de stockage.

Faut-il éviter les variables globales en PHP ?

Une variable globale n’est pas intrinsèquement incorrecte. Son utilisation devient problématique lorsque de nombreuses fonctions dépendent d’un état partagé difficile à identifier.

Prenons :

<?php

$remise = 0.10;

function calculerPrix($prix)
{
    global $remise;

    return $prix * (1 - $remise);
}

Pour comprendre complètement calculerPrix(), le développeur doit rechercher la valeur de $remise ailleurs dans le programme.

Avec :

<?php

function calculerPrix(
    float $prix,
    float $remise
): float {
    return $prix * (1 - $remise);
}

les informations nécessaires sont visibles immédiatement.

Le second modèle simplifie généralement :

• les tests unitaires ;
• la maintenance ;
• la réutilisation ;
• la lecture du code ;
• l’évolution des règles métier.

Quand utiliser une variable globale PHP ?

Les variables globales peuvent rester pratiques dans :

• un petit script procédural ;
• un prototype ;
• un exercice d’apprentissage ;
• certains scripts historiques ;
• une configuration très simple et maîtrisée.

Pour une application plus structurée, les paramètres, objets, services, conteneurs de dépendances et configurations explicites deviennent généralement plus adaptés.

Les erreurs fréquentes avec PHP global variable

Erreur 1 : utiliser une variable globale directement dans une fonction

<?php

$nom = 'Alice';

function afficher()
{
    echo $nom;
}

La fonction ne récupère pas automatiquement $nom.

Une solution est :

function afficher()
{
    global $nom;

    echo $nom;
}

ou, souvent plus clairement :

function afficher(string $nom)
{
    echo $nom;
}

afficher($nom);

Erreur 2 : confondre globale et superglobale

$prix est une variable globale classique.

$_POST est une superglobale.

La seconde reste accessible dans une fonction sans déclaration global.

Erreur 3 : croire qu’une variable globale survit au rechargement

$compteur = 5;

ne constitue pas un stockage persistant.

Après une nouvelle requête, le script est exécuté à nouveau.

Erreur 4 : stocker des secrets dans une variable envoyée au navigateur

Une variable PHP reste côté serveur tant qu’elle n’est pas affichée dans le HTML ou convertie en JavaScript.

Le code suivant expose en revanche sa valeur :

<script>
const secret = <?php echo json_encode($secret); ?>;
</script>

Une donnée sensible ne doit jamais être transmise au navigateur simplement parce qu’elle était initialement stockée dans PHP.

Erreur 5 : utiliser $_REQUEST sans connaître la source

Pour une donnée attendue spécifiquement en POST, préférez :

$_POST['nom']

à une récupération générique via :

$_REQUEST['nom']

Le code indique ainsi clairement l’origine attendue de la donnée.

Exemple pratique : compteur avec variable globale

Voici un petit exemple destiné à comprendre le mécanisme :

<?php

$compteur = 0;

function ajouter(): void
{
    global $compteur;

    $compteur++;
}

ajouter();
ajouter();
ajouter();

echo "Compteur : " . $compteur;

Résultat :

Compteur : 3

Version avec $GLOBALS :

<?php

$compteur = 0;

function ajouter(): void
{
    $GLOBALS['compteur']++;
}

ajouter();
ajouter();
ajouter();

echo "Compteur : " . $compteur;

Résultat identique :

Compteur : 3

Version sans état global :

<?php

function ajouter(int $compteur): int
{
    return $compteur + 1;
}

$compteur = 0;

$compteur = ajouter($compteur);
$compteur = ajouter($compteur);
$compteur = ajouter($compteur);

echo "Compteur : " . $compteur;

Cette dernière approche rend le flux de données explicite.

Tableau récapitulatif des portées de variables en PHP

FAQ — PHP Global Variable

Comment déclarer une variable globale en PHP ?

Une variable déclarée en dehors d’une fonction se trouve dans la portée globale :

$prix = 100;

Pour l’utiliser à l’intérieur d’une fonction avec la syntaxe traditionnelle :

global $prix;

À quoi sert $GLOBALS en PHP ?

$GLOBALS est une superglobale permettant d’accéder aux variables définies dans la portée globale :

$GLOBALS['prix']

Elle permet également de modifier leur valeur.

Quelle différence entre global et $GLOBALS ?

global $prix rend le nom $prix utilisable dans la portée locale de la fonction en le reliant à la variable globale correspondante. $GLOBALS['prix'] accède explicitement à cette variable via le tableau superglobal.

$_SESSION est-elle une variable globale ?

$_SESSION appartient à la catégorie des superglobales PHP. Elle est accessible dans les différentes portées du script une fois la session correctement initialisée.

$_POST est-elle globale en PHP ?

$_POST est une superglobale. Elle peut donc être utilisée à l’intérieur d’une fonction sans écrire :

global $_POST;

Comment créer une variable globale accessible dans toutes les fonctions ?

Le mot-clé global ou $GLOBALS permettent d’accéder à une variable de portée globale. Pour une architecture importante, il est souvent préférable de transmettre la valeur comme paramètre ou de l’encapsuler dans un objet.

Une variable globale PHP est-elle disponible dans JavaScript ?

Pas automatiquement. PHP doit intégrer sa valeur dans la page ou la retourner via une requête HTTP. json_encode() permet notamment de convertir une donnée PHP en représentation JSON exploitable par JavaScript.

Comment conserver une variable globale entre plusieurs pages PHP ?

Une variable globale classique ne suffit pas. Utilisez selon le besoin $_SESSION, une base de données, un cookie, un cache ou un autre mécanisme de persistance.

Comment rendre une variable globale dans une classe PHP ?

Une classe ne doit généralement pas dépendre d’une variable globale externe. Une propriété ou une dépendance transmise au constructeur fournit une structure plus explicite :

class Service
{
    public function __construct(
        private string $configuration
    ) {
    }
}

Pourquoi PHP indique « Undefined variable » dans ma fonction ?

Une cause fréquente consiste à utiliser dans une fonction une variable déclarée uniquement dans la portée globale. Passez-la en paramètre, utilisez global si le contexte le justifie, ou accédez explicitement à $GLOBALS.

À retenir

La notion de PHP global variable repose avant tout sur la portée des variables. Une variable définie hors d’une fonction appartient à la portée globale, mais elle ne devient pas automatiquement disponible dans les fonctions.

PHP propose deux mécanismes directs pour travailler avec cet état global : global et $GLOBALS. Les superglobales telles que $_GET, $_POST, $_SERVER, $_SESSION et $_COOKIE suivent une règle différente puisqu’elles sont accessibles dans toutes les portées.

Pour les petits scripts, une variable globale peut offrir une solution rapide. À mesure que l’application gagne en complexité, les paramètres de fonction, objets, propriétés, configurations structurées et injections de dépendances rendent le flux des données plus explicite et la maintenance plus prévisible.