PHP Gültigkeitsbereich von Variablen

Thema in Kurzform

• Der Begriff Gültigkeitsbereich meint einen Code-Bereich, in dem eine Variable sichtbar (d.h. zugreifbar) ist.
• Eine Variable, die innerhalb einer Funktion definiert ist, ist auch nur dort sichtbar.
• Eine Variable, die außerhalb einer Funktionen definiert ist, kann i.d.R. nicht innerhalb einer Funktion eingesetzt werden.

Inhaltsverzeichnis

1. Lokale und globale Variablen
2. Übergabe von Parametern
3. Das Schlüsselwort global
4. Übungen

Lokale und globale Variablen

Der Gültigkeitsbereich einer Variable (engl. scope) beschreibt den Code-Bereich, in der eine Variable sichtbar ist. Damit ist also der Bereich gemeint, in dem eine bestimmte Variable verfügbar ist.

In diesem Zusammenhang unterscheidet man drei verschiedene Variablentypen:

• Lokale Variablen: Diese werden innerhalb einer Funktion definiert und sind auch nur dort verfügbar.
• Globale Variablen: Diese werden außerhalb von Funktionen definiert und sind standardmäßig innerhalb von Funktionen nicht verfügbar.
• Superglobale Variablen: Das sind sog. PHP-Systemvariablen, die innerhalb und außerhalb von Funktion einsetzbar sind. Hierzu zählt z.B. $_POST.

Wir interessieren uns hier besonders für die lokalen und globalen Variablen. Auf die superglobalen werden wir in einem späteren Kapitel noch einmal genauer eingehen.

Los gehts:

$varGlobal = "Sinope";

function myMoon(){
    $varLokal = "Kallisto";
    echo $varGlobal; // nicht möglich
    echo $varLokal;
}

echo $varGlobal;
echo $varLokal; // nicht möglich

Im Beispiel haben wir zwei Variablen definiert, eine globale ($varGlobal) und eine lokale ($varLokal). Wir versuchen nun an unterschiedlichen Stellen im Code (inner- und außerhalb der Funktion) auf die beiden Variablen zuzugreifen.

Allerdings ist die globale Variable $varGlobal nicht in der Funktion myMoon() sichtbar, da sie ja außerhalb definiert wurde. Die Anweisung echo $varGlobal führt innerhalb der Funktion deshalb zu keiner Ausgabe. Der PHP-Interpreter wird Ihnen den Hinweis Undefined variable... mitteilen.

Auch ist ein Zugriff auf $varLokal außerhalb der Funktion nicht möglich, da die Variable nur innerhalb der Funktion gültig ist. Damit ergibt die Anweisung echo $varLokal; ebenfalls kein Resulat (Undefined variable...).

Der Output des Programms lautet damit:

KallistoSinope

Noch ein Beispiel

Da lokale Variablen nur in der Funktion gültig sind, wo sie definiert wurden, können wir in unterschiedlichen Funktionen denselben Variablennamen verwenden:

function fktA(){
    $var = "Sky";
}

function fktB(){
    $var = "line";
}

Die beiden Variablen haben zwar denselben Namen, sind aber völlig unabhängig voneinander, da sie einen unterschiedlichen Gültigkeitsbereich haben.

Übergabe von Parametern

Wie können wir aber innerhalb einer Funktion mit Werten arbeiten, die von "außerhalb" kommen?

Möglich wird dies mithilfe von Parametern:

potenziere(10);

function potenziere($a){
    echo "Die Potenz von $a ist " . $a * $a;
}

Beim Funktionaufruf übergeben wir den Wert 10. Mit diesem Wert wird nun die Parametervariable $a initialisiert. $a ist nun in der Funktion (und nur dort!) sichtbar.

Pass-by-value

Seien Sie aber vorsichtig, wenn Sie beim Funktionsaufruf Variablen als Argumente übergeben:

$zahl = 4;
doppleMe($zahl);

function doppleMe($a){
    $a *= 2; // 8
}

echo $zahl; // 4

Wir übergeben der Funktion doppleMe() die Variable $zahl als Argument.

Dabei gilt in PHP standardmäßig das Prinzip pass-by-value. Das bedeutet:

• Pass-by-value: Werden Variablen beim Funktionsaufruf eingesetzt, werden deren Werte in die Parametervariable kopiert. Es wird also nur der Inhalt von Variablen in die Funktion übertragen, nicht die Variablen selbst.

Wenn wir nun durch die Funktion die Parametervariablen ändern, hat dies keine Auswirkungen auf die ursprünglichen Variablen. Deshalb hat die Änderung des Werts von $a keine Auswirkungen auf $zahl (behält den Wert 4).

Pass-by-reference

Schreiben wir aber ein &-Zeichen direkt vor den Parameternamen, erfolgt die Argumentenübergabe pass-by-reference.

• Bei pass-by-reference haben Änderungen an der Parametervariablen direkte Auswirkungen auf die Ursprungsvariable.

Ändern wir die Funktion doppleMe() ab, sodass Argumente pass-by-reference übergegen werden. Hierzu schreiben wir das & direkt vor die Parametervariable:

$zahl = 4;
doppleMe($zahl);

function doppleMe(&$a){
    $a *= 2; // 8
}

echo $zahl; // 8

Das Schlüsselwort global

Wie gesagt sind globale Variablen innerhalb von Funktionen nicht sichtbar. Um das zu ändern, benötigen Sie eine Art "Eintrittskarte" zur Funktion.

Diese Eintrittskarte wird durch das Schlüsselwort global markiert.

Hierzu muss innerhalb der Funktion die globale Variable mit dem Schlüssekwort global gekennzeichnet werden:

$a = 1;
$b = 2;

testGlobal();

function testGlobal(){
    global $a;

    echo $a;
    echo $b; // Variable nicht verfügbar!

}

Im Gegensatz zur globalen Variablen $b, kann nach der Anweisung global $a; auf die globale Variable $a in der Funktion zugegriffen werden.

Übungen

$v1 = "Hello";

function earthling(){
    $v2 = "PHP";
}

earthling();
echo $v1;
echo $v2;

$planet1 = "Mars";
$planet2 = "Neptun";


function comparePlanets(string &$p1, string $p2):bool{

    $p1 = "Venus";
    $p2 = "Jupiter";

    if($p1 == $p2){
        return true;
       }
       else{
        return false;
       }
}

echo comparePlanets($planet1, $planet2);
echo $planet1;
echo $planet2;