PHP
Variabler Umfang

Einführung

Benutzerdefinierte globale Variablen

Der Gültigkeitsbereich außerhalb einer Funktion oder Klasse ist der globale Gültigkeitsbereich. Wenn ein PHP-Skript ein anderes enthält ( include oder require ), bleibt der Gültigkeitsbereich unverändert. Wenn ein Skript außerhalb einer Funktion oder Klasse enthalten ist, befinden sich seine globalen Variablen im selben globalen Gültigkeitsbereich. Wenn jedoch ein Skript innerhalb einer Funktion enthalten ist, befinden sich die Variablen im eingebundenen Skript im Funktionsumfang.

Im Rahmen einer Funktions- oder Klassenmethode kann das global Schlüsselwort zum Erstellen von benutzerdefinierten globalen Variablen mit Zugriff verwendet werden.

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

Eine zweite Möglichkeit, auf Variablen aus dem globalen Bereich zuzugreifen, ist die Verwendung des speziellen, von PHP definierten, $ GLOBALS-Arrays.

Das $ GLOBALS-Array ist ein assoziatives Array, wobei der Name der globalen Variablen der Schlüssel und der Inhalt dieser Variablen der Wert des Array-Elements ist. Beachten Sie, wie $ GLOBALS in jedem Bereich existiert, denn $ GLOBALS ist ein Superglobal.

Dies bedeutet, dass die Funktion log_message() folgendermaßen umgeschrieben werden kann:

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

Man könnte fragen, warum das Array $ GLOBALS verwendet wird, wenn das global Schlüsselwort auch verwendet werden kann, um den Wert einer globalen Variablen abzurufen? Der Hauptgrund ist, dass die Verwendung des global Schlüsselworts die Variable in den Geltungsbereich bringt. Sie können dann denselben Variablennamen nicht im lokalen Bereich wiederverwenden.

Superglobale Variablen

Superglobal-Variablen werden von PHP definiert und können ohne das global Schlüsselwort immer und überall verwendet werden.

<?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', '');

Statische Eigenschaften und Variablen

Statische Klasseneigenschaften, die mit der public Sichtbarkeit definiert werden, sind funktional identisch mit globalen Variablen. Auf sie kann von überall her zugegriffen werden, wo die Klasse definiert ist.

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;

Funktionen können auch statische Variablen innerhalb ihres eigenen Bereichs definieren. Diese statischen Variablen bleiben im Gegensatz zu regulären Variablen, die in einem Funktionsbereich definiert sind, durch mehrere Funktionsaufrufe erhalten. Dies ist eine sehr einfache und einfache Möglichkeit, das Singleton-Entwurfsmuster zu implementieren:

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