PHP
Portée variable

Introduction

Variables globales définies par l'utilisateur

La portée en dehors de toute fonction ou classe est la portée globale. Lorsqu'un script PHP en inclut un autre (en utilisant include ou require ), la portée reste la même. Si un script est inclus en dehors de toute fonction ou classe, ses variables globales sont incluses dans la même étendue globale, mais si un script est inclus dans une fonction, les variables du script inclus sont dans la portée de la fonction.

Dans le cadre d'une méthode de fonction ou de classe, le mot clé global peut être utilisé pour créer un accès aux variables globales définies par l'utilisateur.

<?php

$amount_of_log_calls = 0;

function log_message($message) {
    // Accessing global variable from function scope
    // requires this explicit statement
    global $amount_of_log_calls;

    // This change to the global variable is permanent
    $amount_of_log_calls += 1;

    echo $message;
}

// When in the global scope, regular global variables can be used
// without explicitly stating 'global $variable;'
echo $amount_of_log_calls; // 0

log_message("First log message!");
echo $amount_of_log_calls; // 1

log_message("Second log message!");
echo $amount_of_log_calls; // 2

Une seconde façon d'accéder aux variables de la portée globale consiste à utiliser le tableau spécial $ GLOBALS défini par PHP.

Le tableau $ GLOBALS est un tableau associatif avec le nom de la variable globale comme clé et le contenu de cette variable étant la valeur de l'élément tableau. Notez que $ GLOBALS existe dans n'importe quelle portée, c'est parce que $ GLOBALS est une superglobale.

Cela signifie que la fonction log_message() peut être réécrite comme log_message() :

function log_message($message) {
    // Access the global $amount_of_log_calls variable via the
    // $GLOBALS array. No need for 'global $GLOBALS;', since it
    // is a superglobal variable.
    $GLOBALS['amount_of_log_calls'] += 1;

    echo $messsage;
}

On peut se demander pourquoi utiliser le tableau $ GLOBALS lorsque le mot-clé global peut également être utilisé pour obtenir la valeur d'une variable globale. La raison principale est que le mot-clé global amènera la variable dans la portée. Vous ne pouvez pas ensuite réutiliser le même nom de variable dans la portée locale.

Variables superglobales

Les variables superglobales sont définies par PHP et peuvent toujours être utilisées n'importe où sans le mot-clé global .

<?php

function getPostValue($key, $default = NULL) {
    // $_POST is a superglobal and can be used without
    // having to specify 'global $_POST;'
    if (isset($_POST[$key])) {
        return $_POST[$key];
    }

    return $default;
}

// retrieves $_POST['username']
echo getPostValue('username');

// retrieves $_POST['email'] and defaults to empty string
echo getPostValue('email', '');

Propriétés statiques et variables

Les propriétés de classe statique définies avec la visibilité public sont fonctionnellement identiques aux variables globales. Ils sont accessibles depuis n'importe où la classe est définie.

class SomeClass {
    public static int $counter = 0;
}

// The static $counter variable can be read/written from anywhere
// and doesn't require an instantiation of the class
SomeClass::$counter += 1;

Les fonctions peuvent également définir des variables statiques dans leur propre domaine. Ces variables statiques persistent à travers plusieurs appels de fonction, contrairement aux variables régulières définies dans une étendue de fonction. Cela peut être un moyen très simple et facile d'implémenter le modèle de conception Singleton:

class Singleton {
    public static function getInstance() {
        // Static variable $instance is not deleted when the function ends
        static $instance;

        // Second call to this function will not get into the if-statement,
        // Because an instance of Singleton is now stored in the $instance
        // variable and is persisted through multiple calls
        if (!$instance) {
            // First call to this function will reach this line,
            // because the $instance has only been declared, not initialized
            $instance = new Singleton();
        }

        return $instance;

    }
}

$instance1 = Singleton::getInstance();
$instance2 = Singleton::getInstance();

// Comparing objects with the '===' operator checks whether they are
// the same instance. Will print 'true', because the static $instance
// variable in the getInstance() method is persisted through multiple calls
var_dump($instance1 === $instance2);