Portée des variables

La portée d'une variable est le contexte dans lequel elle est définie. PHP possède une portée de fonction et une portée globale. Toute variable définie en dehors d'une fonction est limitée à la portée globale. Lorsqu'un fichier est inclus, le code qu'il contient hérite de la portée des variables de la ligne où l'inclusion a lieu.

Exemple #1 Exemple de portée de variable globale

<?php
$a = 1;
include 'b.inc'; // La variable $a sera disponible dans b.inc.

?>

Toute variable créée à l'intérieur d'une fonction nommée ou d'une fonction anonyme est limitée à la portée du corps de la fonction. Cependant, les fonctions fléchées lient les variables de la portée parente pour les rendre disponibles dans le corps. Si un fichier est inclus à l'intérieur d'une fonction dans le fichier appelant, les variables contenues dans le fichier appelé seront disponibles comme si elles avaient été définies à l'intérieur de la fonction appelante.

Exemple #2 Exemple de portée de variable locale

<?php
$a = 1; // portée globale

function test()
{ 
    echo $a; // La variable $a est indéfinie car elle fait référence à une version locale de $a
}

test();
?>

L'exemple ci-dessus générera un E_WARNING de variable indéfinie (ou un E_NOTICE avant PHP 8.0.0). La raison pour cela est que l'instruction echo utilise la variable locale $a, et celle-ci n'a pas été assignée préalablement dans la fonction. Il est à noter que ce concept diffère un petit peu du langage C dans lequel une variable globale est automatiquement accessible dans les fonctions, à moins d'être redéfinie localement dans la fonction. Cela peut poser des problèmes lors de la redéfinition de variables globales localement. En PHP, une variable globale doit être déclarée à l'intérieur de chaque fonction afin de pouvoir être utilisée dans cette fonction.

Le mot clé `global`

Le mot-clé global est utilisé pour lier une variable de la portée globale dans une portée locale. Le mot-clé peut être utilisé avec une liste de variables ou une seule variable. Une variable locale sera créée faisant référence à la variable globale du même nom. Si la variable globale n'existe pas, la variable sera créée dans la portée globale et assignée à null.

Exemple #3 Exemple avec global

<?php
$a = 1;
$b = 2;

function somme()
{
    global $a, $b;

    $b = $a + $b;
}

somme();
echo $b;
?>

L'exemple ci-dessus va afficher :

En déclarant globales les variables $a et $b locales de la fonction somme(), toutes les références à ces variables concerneront les variables globales. Il n'y a aucune limite au nombre de variables globales qui peuvent être manipulées par une fonction.

Une deuxième méthode pour accéder aux variables globales est d'utiliser le tableau associatif prédéfini $GLOBALS. Le précédent exemple peut être réécrit de la manière suivante :

Exemple #4 Les variables globales et $GLOBALS

<?php
$a = 1;
$b = 2;

function somme()
{
    $GLOBALS['b'] = $GLOBALS['a'] + $GLOBALS['b'];
}

somme();
echo $b;
?>

Le tableau $GLOBALS est un tableau associatif avec le nom des variables globales comme clé et les valeurs des éléments du tableau comme valeur des variables. Il est à noter que $GLOBALS existe dans tous les contextes, car $GLOBALS est un superglobal. Voici un exemple illustrant la puissance des superglobaux :

Exemple #5 Exemple montrant les superglobales et la portée

<?php
function test_superglobal()
{
    echo $_POST['name'];
}
?>

Note: L'utilisation du mot clé global à l'extérieur d'une fonction n'est pas une erreur. Il peut être utilisé si le fichier est inclus depuis l'intérieur d'une fonction.

Utilisation des variables `static`

Une autre caractéristique importante de la portée des variables est la notion de variable static. Une variable statique a une portée locale uniquement, mais elle ne perd pas sa valeur lorsque le script appelle la fonction. Prenons l'exemple suivant :

Exemple #6 Les variables statiques

<?php
function test()
{
    $a = 0;
    echo $a;
    $a++;
}
?>

Cette fonction est un peu inutile car à chaque fois qu'elle est appelée, elle initialise $a à 0 et affiche "0". L'incrémentation de la variable ($a++) ne sert pas à grand chose, car dès que la fonction est terminée, la variable $a disparaît. Pour faire une fonction de comptage utile, c'est-à-dire qui ne perdra pas la trace du compteur, la variable $a est déclarée comme une variable statique :

Exemple #7 Les variables statiques (2)

<?php
function test()
{
    static $a = 0;
    echo $a;
    $a++;
}
?>

Maintenant, la variable $a est initialisée uniquement lors du premier appel à la fonction et, à chaque fois que la fonction test() est appelée, elle affichera une valeur de $a incrémentée de 1.

Les variables statiques sont essentielles lors d'appels récursifs à une fonction. La fonction suivante compte récursivement jusqu'à 10, en utilisant la variable $count pour savoir quand il faut s'arrêter :

Exemple #8 Les variables statiques et la récursivité

<?php
function test()
{
    static $count = 0;

    $count++;
    echo $count;
    if ($count < 10) {
        test();
    }
    $count--;
}
?>

Avant PHP 8.3.0, une variable statique ne pouvait être initialisée qu'en utilisant une expression constante. À partir de PHP 8.3.0, les expressions dynamiques (par exemple, les appels de fonction) sont également autorisées :

Exemple #9 Déclaration de variables statiques

<?php
function foo(){
    static $int = 0;          // correct
    static $int = 1+2;        // correct
    static $int = sqrt(121);  // correct à partir de PHP 8.3.0

    $int++;
    echo $int;
}
?>

Les variables statiques à l'intérieur des fonctions anonymes persistent uniquement au sein de cette instance spécifique de la fonction. Si la fonction anonyme est recréée à chaque appel, la variable statique sera réinitialisée.

Exemple #10 Variables statiques dans les fonctions anonymes

<?php
function exampleFunction($input) {
    $result = (static function () use ($input) {
        static $counter = 0;
        $counter++;
        return "Input: $input, Counter: $counter\n";
    });

    return $result();
}

// Les appels à exampleFunction recréent la fonction anonyme, donc la variable statique
// ne conserve pas sa valeur.
echo exampleFunction('A'); // Affiche : Input: A, Counter: 1
echo exampleFunction('B'); // Affiche : Input: B, Counter: 1
?>

À partir de PHP 8.1.0, lorsqu'une méthode utilisant des variables statiques est héritée (mais pas surchargée), la méthode héritée partage désormais les variables statiques avec la méthode parente. Cela signifie que les variables statiques dans les méthodes se comportent dorénavant de la même manière que les propriétés statiques.

À partir de PHP 8.3.0, les variables statiques peuvent être initialisées avec des expressions arbitraires. Cela signifie que des appels de méthode, par exemple, peuvent être utilisés pour initialiser des variables statiques.

Exemple #11 Utilisation de variables statiques dans les méthodes héritées

<?php
class Foo {
    public static function counter() {
        static $counter = 0;
        $counter++;
        return $counter;
    }
}
class Bar extends Foo {}
var_dump(Foo::counter()); // int(1)
var_dump(Foo::counter()); // int(2)
var_dump(Bar::counter()); // int(3), avant PHP 8.1.0 int(1)
var_dump(Bar::counter()); // int(4), avant PHP 8.1.0 int(2)
?>

Les références avec les variables `global` et `static`

PHP implémente les modificateurs de variables static et global, en termes de référence. Par exemple, une vraie variable globale est importée dans un contexte de fonction avec global. Cette commande crée en fait une référence sur la variable globale. Cela peut mener à des comportements inattendus, par exemple :

<?php
function test_global_ref() {
    global $obj;
    $new = new stdClass;
    $obj = &$new;
}

function test_global_noref() {
    global $obj;
    $new = new stdClass;
    $obj = $new;
}

test_global_ref();
var_dump($obj);
test_global_noref();
var_dump($obj);
?>

L'exemple ci-dessus va afficher :

NULL
object(stdClass)#1 (0) {
}

Un comportement similaire s'applique à la commande static. Les références ne sont pas stockées dynamiquement :

<?php
function &get_instance_ref() {
    static $obj;

    echo 'Static object: ';
    var_dump($obj);
    if (!isset($obj)) {
        $new = new stdClass;
        // Assigne une référence à la variable statique
        $obj = &$new;
    }
    if (!isset($obj->property)) {
        $obj->property = 1;
    } else {
        $obj->property++;
    }
    return $obj;
}

function &get_instance_noref() {
    static $obj;

    echo 'Static object: ';
    var_dump($obj);
    if (!isset($obj)) {
        $new = new stdClass;
        // Assigne l'objet à la variable statique
        $obj = $new;
    }
    if (!isset($obj->property)) {
        $obj->property = 1;
    } else {
        $obj->property++;
    }
    return $obj;
}

$obj1 = get_instance_ref();
$still_obj1 = get_instance_ref();
echo "\n";
$obj2 = get_instance_noref();
$still_obj2 = get_instance_noref();
?>

L'exemple ci-dessus va afficher :

Static object: NULL
Static object: NULL

Static object: NULL
Static object: object(stdClass)#3 (1) {
  ["property"]=>
  int(1)
}

Ces exemples illustrent les problèmes rencontrés lors de l'assignation de référence à des variables statiques, qui sont oubliées lorsque &get_instance_ref() est appelé une seconde fois.

Portée des variables

Le mot clé global

Utilisation des variables static

Les références avec les variables global et static

Le mot clé `global`

Utilisation des variables `static`

Les références avec les variables `global` et `static`