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.
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:
3
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.
static
VariablenEin 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)
?>
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.