PHP
Alcance variable

Introducción

Variables globales definidas por el usuario

El alcance fuera de cualquier función o clase es el alcance global. Cuando un script PHP incluye otro (usando include o require ), el alcance sigue siendo el mismo. Si un script se incluye fuera de cualquier función o clase, sus variables globales se incluyen en el mismo ámbito global, pero si un script se incluye dentro de una función, las variables en el script incluido están en el alcance de la función.

Dentro del alcance de una función o método de clase, la palabra clave global se puede usar para crear un acceso a variables globales definidas por el usuario.

<?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

Una segunda forma de acceder a las variables desde el ámbito global es usar la matriz $ GLOBALS especial definida por PHP.

La matriz $ GLOBALS es una matriz asociativa con el nombre de la variable global que es la clave y el contenido de esa variable es el valor del elemento de la matriz. Observe cómo $ GLOBALS existe en cualquier ámbito, esto se debe a que $ GLOBALS es un superglobal.

Esto significa que la función log_message() podría reescribirse como:

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;
}

Uno podría preguntarse, ¿por qué usar la matriz $ GLOBALS cuando la palabra clave global también se puede usar para obtener el valor de una variable global? La razón principal es que el uso de la palabra clave global traerá la variable al alcance. Entonces no puede reutilizar el mismo nombre de variable en el ámbito local.

Variables superglobales

Las variables superglobales están definidas por PHP y siempre se pueden usar desde cualquier lugar sin la palabra clave 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', '');

Propiedades estáticas y variables

Las propiedades de clase estáticas que se definen con la visibilidad public son funcionalmente las mismas que las variables globales. Se puede acceder desde cualquier lugar donde se defina la clase.

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;

Las funciones también pueden definir variables estáticas dentro de su propio alcance. Estas variables estáticas persisten a través de múltiples llamadas a funciones, a diferencia de las variables regulares definidas en el alcance de una función. Esta puede ser una forma muy fácil y sencilla de implementar el patrón de diseño de 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);