0Pricing
PHP Academy · Leçon

Portée des variables : locale et globale

Comprenez comment PHP isole la portée des fonctions et comment utiliser le mot-clé global.

Portée des variables : locale et globale est une leçon PHP Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage PHP Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours PHP Academy comprend 4 leçons au total.

Portée des variables en PHP

En PHP, chaque variable possède une portée — la région du code où elle est accessible.

  • Les variables créées en dehors des fonctions se trouvent dans la portée globale
  • Les variables créées dans les fonctions se trouvent dans la portée locale
  • PHP ne possède PAS de portée de bloc (contrairement à C ou JavaScript)

Portée locale

Les variables à l'intérieur d'une fonction sont locales — elles disparaissent lorsque la fonction se termine :

<?php
function compute(): void {
    $result = 42;  // local variable
    echo $result;  // 42
}

compute();
echo $result ?? 'undefined';  // undefined — $result is gone

Les variables globales ne sont PAS visibles automatiquement

Contrairement à de nombreux langages, les fonctions PHP ne peuvent pas voir les variables globales par défaut — vous devez les importer explicitement :

<?php
$message = 'Hello';

function printMessage(): void {
    echo $message ?? 'not visible';  // 'not visible'
    // $message from global scope is not accessible here
}

Le mot-clé global

Utilisez global $varName dans une fonction pour accéder à une variable globale :

<?php
$counter = 0;

function increment(): void {
    global $counter;
    $counter++;
}

increment();
increment();
echo $counter;  // 2

Superglobale $GLOBALS

$GLOBALS est un tableau qui contient toutes les variables globales — il est accessible partout sans le mot-clé global :

<?php
$total = 100;

function addTax(): void {
    $GLOBALS['total'] *= 1.18;  // 18% tax
}

addTax();
echo $total;  // 118

Pourquoi éviter global

L'utilisation excessive de global crée des dépendances cachées — les fonctions deviennent difficiles à tester et à déboguer. Préférez transmettre les valeurs comme arguments :

<?php
// Bad
$db = new PDO(/* ... */);
function getUsers(): array {
    global $db;
    return $db->query('SELECT * FROM users')->fetchAll();
}

// Good
function getUsers(PDO $db): array {
    return $db->query('SELECT * FROM users')->fetchAll();
}

Variables statiques

Une variable static conserve sa valeur entre les appels de fonction, tout en restant locale à la fonction :

<?php
function callCount(): int {
    static $count = 0;
    return ++$count;
}

echo callCount();  // 1
echo callCount();  // 2
echo callCount();  // 3

Fermetures et capture de variables

Les fermetures (fonctions anonymes) peuvent capturer des variables externes avec use :

<?php
$prefix = 'Mr';

$greet = function(string $name) use ($prefix): string {
    return "$prefix. $name";
};

echo $greet('Smith');  // Mr. Smith

Capture par référence

Effectuez une capture par référence avec use (&$var) afin que la fermeture puisse modifier la variable externe :

<?php
$total = 0;

$add = function(int $n) use (&$total): void {
    $total += $n;
};

$add(10);
$add(5);
echo $total;  // 15

Fonctions fléchées

Les fonctions fléchées de PHP 7.4 (fn =>) capturent automatiquement la portée externe par valeur — aucun use n'est nécessaire :

<?php
$multiplier = 3;
$nums = [1, 2, 3, 4];

$result = array_map(fn($n) => $n * $multiplier, $nums);

print_r($result);  // [3, 6, 9, 12]

Fonctions imbriquées

PHP permet de définir une fonction à l'intérieur d'une autre, mais la fonction interne devient accessible globalement après l'appel de la fonction externe :

<?php
function outer(): void {
    function inner(): void {
        echo 'inner called';
    }
}

// inner(); // Fatal: undefined before outer() is called
outer();
inner(); // works now

Vérification rapide

Que fait une variable static à l'intérieur d'une fonction PHP ?

Récapitulatif : portée des variables

Règles essentielles concernant la portée en PHP :

  • Les fonctions possèdent leur propre portée locale
  • Les variables globales doivent être importées avec global
  • Utilisez $GLOBALS['name'] comme solution de remplacement
  • Les variables static persistent entre les appels au sein d'une fonction
  • Les fermetures capturent les variables externes avec use
  • Les fonctions fléchées capturent automatiquement par valeur

Questions Fréquemment Posées

La leçon « Portée des variables : locale et globale » est-elle gratuite ?

Oui — le texte complet de « Portée des variables : locale et globale » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours PHP Academy, passe à CoddyKit PRO. Le cours PHP Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Portée des variables : locale et globale » ?

Comprenez comment PHP isole la portée des fonctions et comment utiliser le mot-clé global. Tu pratiques PHP Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer PHP Academy ?

Aucune expérience préalable n'est requise. PHP Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Portée des variables : locale et globale » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon PHP Academy ?

Oui. Chaque leçon PHP Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Définir et appeler des fonctions
  2. Paramètres par défaut et variadiques
  3. Portée des variables : locale et globale
  4. Fonctions anonymes et fermetures
← Retour à PHP Academy