Was ist "variabler Bereich"?
Variablen haben einen begrenzten "Umfang" oder "Orte, von denen aus sie zugänglich sind". Nur weil Sie schrieb $foo = 'bar';einmal irgendwo in der Anwendung bedeutet nicht , dass Sie sich beziehen können $foovon überall sonst in der Anwendung. Die Variable $foohat einen bestimmten Bereich, in dem sie gültig ist, und nur Code im selben Bereich hat Zugriff auf die Variable.
Wie ist ein Bereich in PHP definiert?
Sehr einfach: PHP hat Funktionsumfang . Dies ist die einzige Art von Bereichstrennzeichen, die in PHP vorhanden ist. Variablen innerhalb einer Funktion sind nur innerhalb dieser Funktion verfügbar. Variablen außerhalb von Funktionen sind überall außerhalb von Funktionen verfügbar, jedoch nicht innerhalb einer Funktion. Dies bedeutet, dass es in PHP einen speziellen Bereich gibt: den globalen Bereich. Jede außerhalb einer Funktion deklarierte Variable liegt in diesem globalen Bereich.
Beispiel:
<?php
$foo = 'bar';
function myFunc() {
$baz = 42;
}
$foobefindet sich im globalen Bereich, $bazbefindet sich in einem lokalen Bereich innerhalb myFunc. Nur Code im Inneren myFunchat Zugriff auf $baz. Nur Code außerhalb myFunc hat Zugriff auf $foo. Keiner hat Zugang zum anderen:
<?php
$foo = 'bar';
function myFunc() {
$baz = 42;
echo $foo; // doesn't work
echo $baz; // works
}
echo $foo; // works
echo $baz; // doesn't work
Umfang und enthaltene Dateien
Dateigrenzen trennen den Bereich nicht:
a.php
<?php
$foo = 'bar';
b.php
<?php
include 'a.php';
echo $foo; // works!
Für included-Code gelten dieselben Regeln wie für jeden anderen Code: nur der functionseparate Bereich. Zum Zwecke des Gültigkeitsbereichs können Sie Dateien wie das Kopieren und Einfügen von Code einschließen:
c.php
<?php
function myFunc() {
include 'a.php';
echo $foo; // works
}
myFunc();
echo $foo; // doesn't work!
Im obigen Beispiel a.phpwurde darin enthalten myFunc, dass alle darin enthaltenen Variablen a.phpnur einen lokalen Funktionsumfang haben. Nur weil sie im globalen Bereich zu sein scheinen , a.phpheißt das nicht unbedingt, dass sie es sind, sondern es hängt tatsächlich davon ab, in welchem Kontext dieser Code enthalten ist / ausgeführt wird.
Was ist mit Funktionen innerhalb von Funktionen und Klassen?
Jede neue functionErklärung führt einen neuen Geltungsbereich ein, so einfach ist das.
(anonyme) Funktionen innerhalb von Funktionen
function foo() {
$foo = 'bar';
$bar = function () {
// no access to $foo
$baz = 'baz';
};
// no access to $baz
}
Klassen
$foo = 'foo';
class Bar {
public function baz() {
// no access to $foo
$baz = 'baz';
}
}
// no access to $baz
Wofür ist der Umfang gut?
Der Umgang mit Scoping-Problemen mag ärgerlich erscheinen, aber ein begrenzter variabler Umfang ist für das Schreiben komplexer Anwendungen unerlässlich! Wenn jede von Ihnen deklarierte Variable von überall in Ihrer Anwendung verfügbar wäre, würden Sie Ihre Variablen schrittweise durchlaufen, ohne wirklich nachverfolgen zu können, was was ändert. Es gibt nur so viele sinnvolle Namen, die Sie Ihren Variablen geben können, dass Sie die Variable " $name" wahrscheinlich an mehr als einer Stelle verwenden möchten . Wenn Sie diesen eindeutigen Variablennamen nur einmal in Ihrer App haben könnten, müssten Sie auf wirklich komplizierte Benennungsschemata zurückgreifen, um sicherzustellen, dass Ihre Variablen eindeutig sind und Sie nicht die falsche Variable aus dem falschen Code ändern.
Beobachten:
function foo() {
echo $bar;
}
Was würde die obige Funktion tun, wenn es keinen Bereich gäbe? Woher kommt $bardas? Welchen Zustand hat es? Ist es überhaupt initialisiert? Müssen Sie jedes Mal überprüfen? Dies ist nicht wartbar. Was uns zu ...
Bereichsgrenzen überschreiten
Der richtige Weg: Variablen ein- und ausgeben
function foo($bar) {
echo $bar;
return 42;
}
Die Variable $barkommt explizit als Funktionsargument in diesen Bereich. Wenn man sich diese Funktion ansieht, ist klar, woher die Werte stammen, mit denen sie arbeitet. Es dann explizit zurückgibt einen Wert. Der Aufrufer hat das Vertrauen zu wissen, mit welchen Variablen die Funktion arbeitet und woher ihre Rückgabewerte stammen:
$baz = 'baz';
$blarg = foo($baz);
Erweiterung des Variablenbereichs auf anonyme Funktionen
$foo = 'bar';
$baz = function () use ($foo) {
echo $foo;
};
$baz();
Die anonyme Funktion schließt explizit $fooaus ihrem umgebenden Bereich ein. Beachten Sie, dass dies nicht mit dem globalen Bereich identisch ist .
Der falsche Weg: global
Wie bereits erwähnt, ist der globale Bereich etwas Besonderes, und Funktionen können explizit Variablen daraus importieren:
$foo = 'bar';
function baz() {
global $foo;
echo $foo;
$foo = 'baz';
}
Diese Funktion verwendet und ändert die globale Variable $foo. Mach das nicht! (Es sei denn, Sie wissen wirklich wirklich wirklich wirklich, was Sie tun, und selbst dann: nicht!)
Der Aufrufer dieser Funktion sieht lediglich Folgendes:
baz(); // outputs "bar"
unset($foo);
baz(); // no output, WTF?!
baz(); // outputs "baz", WTF?!?!!
Es gibt keinen Hinweis darauf, dass diese Funktion Nebenwirkungen hat , dies ist jedoch der Fall. Dies wird sehr leicht zu einem Durcheinander, da einige Funktionen ständig geändert werden und einen globalen Status erfordern . Sie möchten, dass Funktionen zustandslos sind , nur auf ihre Eingaben reagieren und definierte Ausgaben zurückgeben, wie oft Sie sie auch aufrufen.
Sie sollten es vermeiden, den globalen Bereich so weit wie möglich zu verwenden. Mit Sicherheit sollten Sie keine Variablen aus dem globalen Bereich in einen lokalen Bereich "ziehen".