Geltungsbereich von Variablen
Der Geltungsbereich einer Variablen ergibt sich aus dem Zusammenhang, in
dem sie definiert wurde. Meistens besteht dieser aus einem einzigen
Bereich. Dieser beinhaltet auch den Bereich für Dateien, die per
"include"- oder "require"-Anweisung eingebunden wurden, z. B.:
Hier ist die Variable $a auch in der eingebundenen
Datei b.inc verfügbar. In benutzerdefinierten
Funktionen wird jedoch ein auf die Funktion beschränkter Geltungsbereich
eingeführt. Jede in einer Funktion verwendete Variable ist zunächst auf
den lokalen Bereich der Funktion beschränkt, z. B.:
Dieses Skript erzeugt bei einer nicht definierten Variable eine Meldung
der Stufe E_WARNING
(oder der Stufe
E_NOTICE
vor PHP 8.0.0). Wenn jedoch die
INI-Einstellung display_errors
so eingestellt ist, dass solche Meldungen nicht angezeigt werden, wird
überhaupt nichts ausgegeben. Das liegt daran, dass sich die echo-Anweisung
auf eine lokale Variable namens $a bezieht, und dieser
kein Wert im lokalen Geltungsbereich zugewiesen worden ist. Dies ist ein
kleiner Unterschied zu C, wo globale Variablen auch in Funktionen vorhanden
sind, es sei denn, sie werden durch eine funktionsinterne Definition
überschrieben. Das kann zu Problemen führen, sodass in PHP global geltende
Variablen innerhalb von Funktionen als solche deklariert werden müssen.
Das Schlüsselwort global
Zunächst ein Beispiel für die Verwendung von global
:
Beispiel #1 Verwendung von global
<?php
$a = 1;
$b = 2;
function Sum()
{
global $a, $b;
$b = $a + $b;
}
Sum();
echo $b;
?>
Das obige Skript gibt 3
aus. 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 #2 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 #3 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 #4 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 #5 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. Das sind Funktionen, die sich selbst aufrufen. Hierbei besteht
die Gefahr, sogenannte Endlosschleifen zu programmieren. Sie müssen also
einen Weg vorsehen, diese Rekursion zu beenden. Die folgende einfache
Funktion zählt rekursiv bis 10. Die statische Variable
$count wird verwendet, um die Rekursion zu beenden:
Beispiel #6 Statische Variablen in rekursiven Funktionen
<?php
function test()
{
static $count = 0;
$count++;
echo $count;
if ($count < 10) {
test();
}
$count--;
}
?>
Statischen Variablen können Werte zugewiesen werden, die das Ergebnis
konstanter Ausdrücken sind, aber dynamische Ausdrücke, z. B.
Funktionsaufrufe, verursachen einen Parse-Fehler.
Beispiel #7 Statische Variablen deklarieren
<?php
function foo(){
static $int = 0; // korrekt
static $int = 1+2; // korrekt
static $int = sqrt(121); // falsch (da es eine Funktion ist)
$int++;
echo $int;
}
?>
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.
Beispiel #8 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)
?>
Hinweis:
Statische Deklarationen werden bei der Kompilierung aufgelöst.
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:
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:
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.