Geltungsbereich von Variablen

Der Geltungsbereich einer Variablen ergibt sich aus dem Zusammenhang, in dem sie definiert wurde. PHP hat einen Funktionsbereich und einen globalen Bereich. Jede Variable, die außerhalb einer Funktion definiert wird, ist auf den globalen Bereich beschränkt. Wenn eine Datei eingebunden wird, erbt der darin enthaltene Code den Variablenbereich der Zeile, in der die Einbindung erfolgt.

Beispiel #1 Beispiel für den Geltungsbereich globaler Variablen

<?php
$a = 1;
include 'b.inc'; // Die Variable $a wird in b.inc verfügbar sein
?>

Jede Variable, die innerhalb einer benannten Funktion oder einer anonymen Funktion erstellt wird, ist auf den Bereich des Funktionskörpers beschränkt. Im Gegensatz dazu binden Pfeilfunktionen Variablen aus dem übergeordneten Bereich, um sie im Körper verfügbar zu machen. Wenn eine Datei innerhalb einer Funktion der aufrufenden Datei eingebunden wird, sind die in der aufgerufenen Datei enthaltenen Variablen so verfügbar, als wären sie innerhalb der aufrufenden Funktion definiert worden.

Beispiel #2 Beispiel für den Geltungsbereich lokaler Variablen

<?php
$a = 1; // globaler Geltungsbereich

function test()
{
    echo $a; // Die Variable $a ist undefiniert, da sie sich auf eine lokale
             // Version von $a bezieht
}
?>

Das obige Beispiel erzeugt ein E_WARNING wegen einer undefinierten Variable (oder ein E_NOTICE vor PHP 8.0.0). Das liegt daran, dass sich die echo-Anweisung auf eine lokale Variable namens $a bezieht, und dieser kein Wert im lokalen Geltungsbereich zugewiesen wurde. Es ist zu beachten, dass sich dies etwas von C unterscheidet, da in C globale Variablen automatisch für Funktionen zur Verfügung stehen, es sei denn, sie werden durch eine funktionsinterne Definition überschrieben. Dies kann zu Problemen führen, da eine globale Variable versehentlich geändert werden kann. In PHP müssen globale Variablen innerhalb einer Funktionen deklariert werden, wenn sie in dieser Funktion verwendet werden sollen.

Das Schlüsselwort `global`

Das Schlüsselwort global wird verwendet, um eine Variable aus einem globalen Bereich in einen lokalen Bereich zu binden. Das Schlüsselwort kann mit einer Liste von Variablen oder einer einzelnen Variablen verwendet werden. Es wird eine lokale Variable erstellt, die auf die gleichnamige globale Variable verweist. Wenn die globale Variable nicht existiert, wird sie im globalen Bereich erstellt und erhält den Wert null.

Beispiel #3 Verwendung von global

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

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

    $b = $a + $b;
}

Sum();
echo $b;
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

Durch das Deklarieren der Variablen $a und $b innerhalb der Funktion als global weisen alle Referenzen zu beiden Variablen auf die nun globalen Werte. Es gibt keine Beschränkungen bei der Anzahl an globalen Variablen, die durch eine Funktion verändert werden können.

Eine weitere Möglichkeit, auf Variablen aus dem globalen Bereich zuzugreifen, besteht in der Verwendung des speziellen, von PHP definierten Arrays $GLOBALS. Das obige Beispiel kann damit auch so geschrieben werden:

Beispiel #4 Verwendung von $GLOBALS statt global

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

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

Sum();
echo $b;
?>

Das $GLOBALS-Array ist ein assoziatives Array mit dem Namen der globalen Variablen als Schlüssel und dem Inhalt dieser Variablen als Wert des Array-Elements. Beachten Sie, dass $GLOBALS in jedem Geltungsbereich existiert, weil $GLOBALS eine Superglobale ist. Hier ist ein Beispiel, das die Stärke von Superglobalen verdeutlicht:

Beispiel #5 Beispiel zur Demonstration von Superglobalen und Geltungsbereich

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

Hinweis: Die Verwendung des Schlüsselworts global außerhalb einer Funktion ist kein Fehler. Es kann verwendet werden, wenn die Datei innerhalb einer Funktion eingebunden wird.

Die Verwendung von `static` Variablen

Ein weiterer wichtiger Anwendungszweck von Variablen-Bereichen ist die statische Variable. Eine statische Variable existiert nur in einem lokalen Funktions-Geltungsbereich, der Wert geht beim Verlassen dieses Bereichs aber nicht verloren. Schauen Sie das folgende Beispiel an:

Beispiel #6 Beispiel, das die Notwendigkeit von statischen Variablen demonstriert

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

Diese Funktion ist sinnlos, da sie bei jedem Aufruf $a auf 0 setzt und 0 ausgibt. Die Anweisung $a++, welche den Wert erhöht, erfüllt keinen Zweck, da der Wert von $a beim Verlassen der Funktion verloren geht. Um eine sinnvolle Zählfunktion zu implementieren, die ihren aktuell gesetzten Wert nicht vergisst, müssen Sie die Variable $a als statisch deklarieren:

Beispiel #7 Beispiel zur Verwendung statischer Variablen

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

Nun wird $a nur beim ersten Aufruf der Funktion initialisiert, und jedes mal wenn die Funktion test() aufgerufen wird, wird sie den Wert von $a ausgeben und den Variablenwert erhöhen.

Statische Variablen ermöglichen auch einen Weg zum Umgang mit rekursiven Funktionen. Die folgende einfache Funktion zählt rekursiv bis 10. Die statische Variable $count wird verwendet, um die Rekursion zu beenden:

Beispiel #8 Statische Variablen in rekursiven Funktionen

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

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

Vor PHP 8.3.0 konnten statische Variablen nur mit einem konstanten Ausdruck initialisiert werden. Seit PHP 8.3.0 sind auch dynamische Ausdrücke (z. B. Funktionsaufrufe) erlaubt:

Beispiel #9 Statische Variablen deklarieren

<?php
function foo(){
    static $int = 0;          // korrekt
    static $int = 1+2;        // korrekt
    static $int = sqrt(121);  // korrekt seit PHP 8.3.0

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

Statische Variablen innerhalb anonymer Funktionen bleiben nur innerhalb der jeweiligen Funktionsinstanz bestehen. Wenn die anonyme Funktion bei jedem Aufruf neu erstellt wird, wird die statische Variable neu initialisiert.

Beispiel #10 Statische Variablen in anonymen Funktionen

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

    return $result();
}

// Bei Aufrufen von exampleFunction wird die anonyme Funktion neu erstellt,
// so dass die statische Variable ihren Wert nicht beibehält.
echo exampleFunction('A'); // Ausgabe: Eingabe: A, Zähler: 1
echo exampleFunction('B'); // Ausgabe: Eingabe: B, Zähler: 1
?>

Wenn eine Methode, die statische Variablen verwendet, vererbt (aber nicht überschrieben) wird, teilt die vererbte Methode seit PHP 8.1.0 die statischen Variablen mit der Elternmethode. Das bedeutet, dass sich statische Variablen in Methoden nun genauso verhalten wie statische Eigenschaften.

Seit PHP 8.3.0 können statische Variablen mit beliebigen Ausdrücken initialisiert werden. Das bedeutet, dass z. B. Methodenaufrufe verwendet werden können, um statische Variablen zu initialisieren.

Beispiel #11 Verwendung statischer Variablen in geerbten Methoden

<?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), vor PHP 8.1.0 int(1)
var_dump(Bar::counter()); // int(4), vor PHP 8.1.0 int(2)
?>

Referenzen bei `global` und `static` Variablen

PHP implementiert die Modifikatoren static und global für Variablen als Referenzen. Zum Beispiel erzeugt eine echte globale Variable, die mit der Anweisung global in den Funktions-Geltungsbereich importiert wurde, tatsächlich eine Referenz zur globalen Variable. Das kann zu einem unerwarteten Verhalten führen, auf das im folgenden Beispiel eingegangen wird:

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

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

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

Ein ähnliches Verhalten gilt auch für die Anweisung static. Referenzen werden nicht statisch gespeichert:

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

    echo 'Statisches Objekt: ';
    var_dump($obj);
    if (!isset($obj)) {
        $new = new stdClass;
        // Der statischen Variablen eine Referenz zuweisen
        $obj = &$new;
    }
    if (!isset($obj->property)) {
        $obj->property = 1;
    } else {
        $obj->property++;
    }
    return $obj;
}

function &get_instance_noref() {
    static $obj;

    echo 'Statisches Objekt: ';
    var_dump($obj);
    if (!isset($obj)) {
        $new = new stdClass;
        // Der statischen Variablen ein Objekt zuweisen
        $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();
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

Statisches Objekt: NULL
Statisches Objekt: NULL

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

Dieses Beispiel demonstriert, dass die Referenz, die einer statischen Variablen zugewiesen wird, beim zweiten Aufruf der Funktion &get_instance_ref() vergessen ist.

Geltungsbereich von Variablen

Das Schlüsselwort global

Die Verwendung von static Variablen

Referenzen bei global und static Variablen

Das Schlüsselwort `global`

Die Verwendung von `static` Variablen

Referenzen bei `global` und `static` Variablen