PHP7 – PHP: Global innerhalb einer Funktion zeigt keine Variable an – Stapelüberlauf auf Russisch. Umfang der PHP-Variablen. Alles, was Sie wissen wollten, aber nicht zu fragen wagten. Drucken Sie eine globale PHP-Variable außerhalb einer Funktion

Letzte Aktualisierung: 01.11.2015

Berücksichtigen Sie bei der Verwendung von Variablen und Funktionen den Variablenbereich. Der Bereich gibt den Aktionsbereich und die Zugänglichkeit einer bestimmten Variablen an.

Lokale Variablen

Lokale Variablen werden innerhalb einer Funktion erstellt. Auf solche Variablen kann nur innerhalb einer bestimmten Funktion zugegriffen werden. Zum Beispiel:

In diesem Fall definiert die Funktion get() eine lokale Variable $result . Und aus dem allgemeinen Kontext heraus können wir nicht darauf zugreifen, das heißt, schreiben Sie $a = $result; Dies ist nicht möglich, da der Umfang der Variablen $result durch die Funktion get() begrenzt ist. Außerhalb dieser Funktion existiert die Variable $result nicht.

Gleiches gilt für Funktionsparameter: Außerhalb der Funktion existieren auch die Parameter $lowlimit und $highlimit nicht.

Lokale Variablen speichern in der Regel einige Zwischenergebnisse von Berechnungen, wie im obigen Beispiel.

Statische Variablen

Statische Variablen ähneln lokalen Variablen. Sie unterscheiden sich dadurch, dass ihr Wert nach Abschluss der Funktion gespeichert wird. Bei jedem Aufruf der Funktion wird der zuvor gespeicherte Wert verwendet. Zum Beispiel:

Um anzuzeigen, dass eine Variable statisch ist, wird ihr das Schlüsselwort static hinzugefügt. Bei drei aufeinanderfolgenden Aufrufen von getCounter() wird die Variable $counter um eins erhöht.

Wenn die Variable $counter eine reguläre, nicht statische Variable wäre, würde getCounter() bei jedem Aufruf 1 ausgeben.

Typischerweise werden statische Variablen zum Erstellen verschiedener Zähler verwendet, wie im obigen Beispiel.

Globale Variablen

Manchmal möchten Sie, dass eine Variable überall und weltweit verfügbar ist. Solche Variablen können einige Daten speichern, die für das gesamte Programm gelten. Um globale Variablen zu definieren, verwenden Sie das globale Schlüsselwort:1

"; ) getGlobal(); echo $gvar; ?>

Nach dem Aufruf der Funktion getGlobal() kann von jedem Teil des Programms aus auf die Variable $gvar zugegriffen werden.

Die Notiz: Die adaptive Version der Website ist aktiviert, die sich automatisch an die geringe Größe Ihres Browsers anpasst und einige Details der Website ausblendet, um das Lesen zu erleichtern. Genieße das Zusehen!

Hallo liebe Blog-Leser Website An! In haben wir gelernt, dass es in PHP eine Funktion gibt, wir haben gelernt, wie wir unsere eigenen Funktionen erstellen, ihnen Argumente übergeben und sie zur Ausführung aufrufen. Um das Thema Funktionen in PHP fortzusetzen, müssen folgende Dinge hervorgehoben werden:

  • Innerhalb der Funktion können Sie jeden PHP-Code (Zyklen, Bedingungen, beliebige Operationen) verwenden, einschließlich anderer Funktionen (sowohl integrierte als auch benutzerdefinierte);
  • Der Funktionsname muss mit einem lateinischen Buchstaben oder einem Unterstrich beginnen, gefolgt von einer beliebigen Anzahl lateinischer Buchstaben, Zahlen oder Unterstriche;
  • Alle Funktionen haben einen globalen Geltungsbereich, was bedeutet, dass jede Funktion überall aufgerufen werden kann, auch wenn diese Funktion in einer anderen definiert ist;
  • PHP unterstützt keine Funktionsüberladung; es gibt auch keine Möglichkeit, eine erstellte Funktion neu zu definieren (ändern, hinzufügen) oder zu löschen;
  • Funktionen müssen vor ihrer Verwendung nicht definiert werden. Das heißt, wenn Sie zuerst eine Funktion aufrufen und sie erst dann im folgenden Code beschreiben, hat dies keinen Einfluss auf die Leistung und verursacht keine Fehler.

Bedingte Funktionen

Abhängig von der Bedingung können wir eine Funktion erstellen (definieren, beschreiben). Zum Beispiel:

//Funktion aufgerufen sayHi, sie kann überall aufgerufen werden /*Die Funktion sayGoodbye kann hier nicht aufgerufen werden, da wir die Bedingung noch nicht überprüft haben und noch nicht in das if-Konstrukt eingestiegen sind*/ if($apply)( function sayGoodbye())( echo „Tschüs alle!
"; } } /*Jetzt können wir sayGoodbye aufrufen*/
"; }

Ergebnis:

Und schauen Sie sich dieses Beispiel an:

/*und das passiert, wenn du hier sayGoodbye aufrufst*/ Auf wiedersehen sagen(); if($apply)( function sayGoodbye())( echo „Tschüs alle!
"; ) ) function sayHi())( echo "Hallo zusammen!
"; }

Ergebnis:

Obwohl ich so viel gearbeitet habe, habe ich so etwas noch nirgendwo gesehen, aber man muss alle Möglichkeiten der Sprache im Auge behalten.

Verschachtelte Funktionen

Eine verschachtelte Funktion ist eine Funktion, die innerhalb einer anderen Funktion deklariert wird. Beispiel:

/*Sie können sayGoodbye hier nicht aufrufen, da es erst nach Aufruf der sayHi-Funktion erscheint*/ Sag Hallo(); /*Rufen Sie die Funktion sayHi auf, sie kann überall aufgerufen werden*/ /*Jetzt können wir sayGoodbye aufrufen*/ Auf wiedersehen sagen(); Funktion sayHi())( echo „Hallo allerseits!
"; function sayGoodbye())( echo "Tschüs alle!
"; } }

Auch hier markiert sich der PHP-Interpreter beim ersten Durchlauf, dass er eine Beschreibung der sayHi-Funktion gefunden hat, geht aber nicht in deren Rumpf, sondern sieht nur den Namen, und da der Interpreter nicht in den Rumpf von sayHi geht, dann hat es keine Ahnung, was wir in einer anderen Funktion definieren – sayGoodbye.

Dann beginnt der Code mit der Ausführung, wir rufen sayHi auf, der PHP-Interpreter muss in den Hauptteil der Funktion sayHi gehen, um ihn auszuführen, und findet dort zufällig die Beschreibung einer anderen Funktion – sayGoodbye, woraufhin sayGoodbye beliebig oft überall aufgerufen werden kann wie Sie möchten.

Es lohnt sich jedoch, in der obigen Situation auf einen sehr subtilen Punkt zu achten: Die SayHi-Funktion wird einmalig, denn wenn wir sie erneut aufrufen, stößt PHP wieder auf die Definition der SayGoodbye-Funktion, und das ist in PHP nicht möglich Dies - Sie können Funktionen nicht überschreiben. Darüber und wie man damit umgeht, habe ich in einem früheren Artikel geschrieben.

In PHP kommen die oben beschriebenen Techniken nur sehr selten zum Einsatz, häufiger sind sie beispielsweise in JavaScript zu sehen.

Variabler Umfang

In PHP gibt es genau zwei Bereiche: global Und lokal. Jede Programmiersprache strukturiert Bereiche anders. Beispielsweise haben in C++ sogar Schleifen ihren eigenen (lokalen) Gültigkeitsbereich. In PHP ist dies übrigens ein globaler Bereich. Aber heute reden wir über Funktionen.

Funktionen in PHP haben ihren eigenen internen Bereich (lokal), d. h. alle Variablen innerhalb einer Funktion sind nur innerhalb dieser Funktion sichtbar.

Also noch einmal: Alles außerhalb der Funktionen ist der globale Geltungsbereich, alles innerhalb der Funktionen ist der lokale Geltungsbereich. Beispiel:

Liebe Experten, Achtung, Frage! Was wird die letzte Anweisung ausgeben? echo $name; ?

Wie Sie selbst gesehen haben, hatten wir zwei Variablen $name, einer innerhalb der Funktion (lokaler Gültigkeitsbereich), der andere nur im Code (globaler Gültigkeitsbereich), die letzte Zuweisung an eine Variable $name War $name = "Rud Sergey"; Aber da es sich innerhalb der Funktion befand, blieb es dort. Im globalen Bereich war die letzte Zuweisung $name = "Andrey"; Das ist es, was wir tatsächlich als Ergebnis sehen.

Das heißt, zwei identische Variablen, die sich jedoch in unterschiedlichen Bereichen nicht überschneiden und sich nicht gegenseitig beeinflussen.

Lassen Sie mich den Umfang in der Abbildung veranschaulichen:

Beim ersten Durchlauf durchsucht der Interpreter kurz den globalen Gültigkeitsbereich, merkt sich, welche Variablen und Funktionen vorhanden sind, führt den Code jedoch nicht aus.

Zugriff auf globale Variablen aus dem lokalen Bereich

Aber was ist, wenn wir von einer Funktion aus immer noch auf dieselbe $name-Variable aus dem globalen Bereich zugreifen müssen und nicht nur darauf zugreifen, sondern sie ändern müssen? Hierfür gibt es 3 Hauptoptionen. Der erste verwendet das Schlüsselwort global:

"; globaler $name; /*von nun an meinen wir die globale Variable $name*/$name = "Rud Sergey"; ) $name = "Andrey"; sayHi($name); echo $name; // ?

Ergebnis:

Diese Methode hat jedoch einen Nachteil, da wir auf die globale Variable zugegriffen haben $name Wir haben eine lokale Variable verloren (überschrieben). $name.

Zweiter Weg ist zu verwenden Superglobales PHP-Array. PHP selbst platziert automatisch jede Variable, die wir im globalen Bereich erstellt haben, in diesem Array. Beispiel:

$name = "Andrey"; //Gleich wie$GLOBALS["name"] = "Andrey";

Somit:

"; $GLOBALS["name"] = "Rud Sergey"; ) $name = "Andrey"; sayHi($name); echo $name; // ?

Das Ergebnis ist dasselbe wie bei Verwendung des Schlüsselworts global:

Nur dieses Mal haben wir die lokale Variable, also die Variable, nicht neu geschrieben $name innerhalb der Funktion bleibt gleich und ist gleich „Andrei“, und nicht „Rud Sergey“.

Argumente als Referenz übergeben

Dritter Weg– das ist die Adressübermittlung ( Links) einer Variablen, nicht ihr Wert. Im Gegensatz zu anderen Programmiersprachen sind Links in PHP nicht sehr erfolgreich. Ich verrate Ihnen jedoch die einzig richtige Option zum Übergeben eines Arguments als Verweis auf eine Funktion, die normalerweise in PHP 5.3 und höher unterstützt wird. Es gibt andere Möglichkeiten, mit Links zu arbeiten, aber sie funktionierten in PHP 5.2 und niedriger. Aus diesem Grund haben die PHP-Entwickler selbst beschlossen, sie aufzugeben, daher werden wir nicht darüber sprechen.

Die RICHTIGE Übergabe eines Arguments per Referenz in PHP 5.3 und höher erfolgt also wie folgt:

Funktion sayHi(& $name)(

In der Funktionsbeschreibung selbst haben wir ein kaufmännisches Und-Symbol (&) hinzugefügt. Dieses Symbol bedeutet, dass wir nicht den Wert der Variablen akzeptieren, sondern einen Link (Adresse) zu diesem Wert im Speicher. Mit Referenzen in PHP können Sie zwei Variablen erstellen, die auf denselben Wert verweisen. Das heißt, wenn sich eine dieser Variablen ändert, ändern sich auch beide, da sie auf denselben Wert im Speicher verweisen.

Und am Ende haben wir:

//Akzeptiere keinen Wert, sondern eine Referenz auf den Wert echo „Hallo, „.$name.“!
"; $name = "Rud Sergey"; ) $name = "Andrey"; sayHi($name); echo $name; // ?

Ergebnis:

Statische Variablen

Stellen Sie sich die folgende Situation vor: Wir müssen zählen, wie oft wir insgesamt Hallo gesagt haben. Folgendes versuchen wir:

"; $c++; // Erhöhe den Zähler um 1

Ergebnis:

Variable $c erinnert sich nicht an seine Bedeutung, es wird jedes Mal neu erschaffen. Wir müssen unsere lokale Variable erstellen $c hat sich seinen Wert nach der Ausführung der Funktion gemerkt, dafür verwenden sie ein Schlüsselwort statisch:

// Zähler, statisch gemacht echo „Hallo, „.$name.“!
"; $c++; // Erhöhe den Zähler um 1 echo „Ich habe gerade Hallo gesagt“. $c . " einmal.

"; ) sayHi("Rud Sergey"); sayHi("Andrey"); sayHi("Dmitry");

Ergebnis:

Werte zurückgeben

Funktionen haben eine so praktische Funktion wie die Rückgabe von Werten. Dies ist der Fall, wenn eine Funktion, anstatt etwas auf dem Bildschirm auszugeben, alles in eine Variable einfügt und diese Variable an uns weitergibt. Und wir entscheiden bereits, was wir damit machen. Nehmen wir zum Beispiel diese Funktion, sie quadriert eine Zahl:

Ergebnis:

Machen wir es so, dass es das Ausführungsergebnis zurückgibt, anstatt es auf dem Bildschirm anzuzeigen. Verwenden Sie dazu das Schlüsselwort return:

Ergebnis:

Nun können wir dies auf verschiedene Arten nutzen:

//gibt das Ergebnis aus Echo“
"; $num = getSquare(5); echo $num;

Ergebnis:

Bitte beachten Sie, dass das Schlüsselwort zurückkehren gibt nicht nur einen Wert zurück, sondern unterbricht die Funktion, also den gesamten Code, der sich unter dem Schlüsselwort befindet, vollständig zurückkehren wird nie erfüllt werden. Mit anderen Worten, die Rückgabe für Funktionen funktioniert auch so brechen for-Schleifen:

echo „PHP wird mich nie erreichen:(“;) echo getSquare(5); //gibt das Ergebnis aus Echo“
"; $num = getSquare(5); // das Ergebnis einer Variablen zugewiesen echo $num; // die Variable auf dem Bildschirm anzeigen

Ergebnis:

Also zurückkehren– Dies ist auch ein Ausstieg aus der Funktion. Es kann ohne Rückgabewert verwendet werden, nur für die Ausgabe.

Rekursive Funktion

Eine rekursive Funktion ist eine Funktion, die sich selbst aufruft. Rekursion wird nicht oft verwendet und gilt als ressourcenintensiver (langsamer) Vorgang. Es kommt jedoch vor, dass die Verwendung der Rekursion die naheliegendste und einfachste Option ist. Beispiel:

"; if($number< 20){ // damit die Rekursion nicht endlos wird countPlease(++$number); // die countPlease-Funktion hat sich selbst aufgerufen) ) countPlease(1);

Ergebnis:

Wenn Sie wissen, wie man ohne Rekursion auskommt, ist es besser, dies zu tun.

Starkes Typisieren in PHP (Typverfeinerung)

PHP unternimmt kleine Schritte in Richtung starker Typisierung, sodass wir im Voraus festlegen können, welchen Typ eine Funktion annehmen soll (dies wird aufgerufen). Typhinweis):

Ergebnis:

Abfangbarer schwerwiegender Fehler: Argument 1, das an countPlease() übergeben wird, muss ein Array mit angegebener Ganzzahl sein, das in /home/index.php in Zeile 7 aufgerufen und in /home/index.php in Zeile 3 definiert wird

Der Fehler sagt uns, dass die Funktion den Empfang eines Arrays erwartet, wir ihm aber stattdessen eine Zahl übergeben. Leider können wir vorerst nur den Typ für (Array) angeben, und mit PHP 5.4 haben wir auch eine Option wie hinzugefügt abrufbar:

Abrufbar prüft, ob der übergebene Wert als Funktion aufgerufen werden kann. Callable kann entweder der Name einer durch eine String-Variable angegebenen Funktion oder ein Objekt und der Name der aufgerufenen Methode sein. Aber wir werden später über Objekte und Methoden sprechen (dies ist ein Abschnitt der objektorientierten Programmierung), aber Sie sind bereits mit Funktionen vertraut. Das Ergebnis der Arbeit kann ich Ihnen nicht zeigen, da ich derzeit PHP 5.3 habe, aber es wäre:

Wird als getEcho-Funktion bezeichnet

Verwendung von Argumenten variabler Länge

Und zum Schluss noch eine sehr selten verwendete Nuance. Stellen Sie sich eine Situation vor: Wir übergeben Argumente an eine Funktion, obwohl wir sie in der Funktion nicht beschrieben haben, zum Beispiel:

Ergebnis:

Wie Sie sehen, gibt es keine Fehler, aber unsere übergebenen Argumente werden nirgendwo verwendet. Das heißt aber nicht, dass sie weg sind – sie wurden immer noch an die Funktion übergeben und wir können sie verwenden; dafür gibt es eingebaute PHP-Funktionen:

func_num_args()– Gibt die Anzahl der an die Funktion übergebenen Argumente zurück
func_get_arg(Sequenznummer)– Gibt ein Element aus einer Liste von Argumenten zurück
func_get_args()– Gibt ein Array zurück, das die Funktionsargumente enthält

"; echo func_get_arg(0) ; ) $age = 22; getEcho("Rud Sergey", $age);

Ergebnis:

Abschluss

Der heutige Artikel ist der letzte zum Thema Funktionen in PHP. Jetzt können Sie sich auf die Vollständigkeit Ihres Wissens zu diesem Thema verlassen und die Funktionen sicher für Ihre Bedürfnisse nutzen.

Wenn jemand den Wunsch hat, darin besser zu werden, aber keine Ahnung hat, wie das geht, ist es am besten, vorgefertigte (eingebaute) PHP-Funktionen zu schreiben. Sie können beispielsweise Ihre eigene count()-Funktion schreiben oder irgend ein anderer.

Vielen Dank für Ihre Aufmerksamkeit und wir sehen uns wieder! Wenn etwas nicht klar ist, können Sie Ihre Fragen gerne in den Kommentaren stellen!

Dieses Tutorial behandelt den Umfang von PHP-Variablen. Erklärt den Unterschied zwischen lokalem und globalem Gültigkeitsbereich, zeigt, wie man innerhalb einer Funktion auf globale Variablen zugreift, wie man mit Superglobals arbeitet und statische Variablen erstellt.

Wenn Sie anfangen, PHP zu lernen und mit Funktionen und Objekten zu arbeiten, ist der Variablenbereich etwas verwirrend. Glücklicherweise sind die diesbezüglichen Regeln von PHP (im Vergleich zu anderen Programmiersprachen) sehr einfach zu verstehen.

Was ist Umfang?

Der Gültigkeitsbereich von Variablen ist der Kontext, in dem die Variable definiert wurde und in dem auf sie zugegriffen werden kann. PHP hat zwei Variablenbereiche:

  • Global- Auf Variablen kann überall im Skript zugegriffen werden
  • Lokal- Auf Variablen kann nur innerhalb der Funktion zugegriffen werden, in der sie definiert wurden

Der Gültigkeitsbereich einer Variablen, insbesondere des lokalen, vereinfacht die Codeverwaltung erheblich. Wenn alle Variablen global wären, könnten sie an einer beliebigen Stelle im Skript geändert werden. Dies würde zu Chaos und großen Skripten führen, da sehr oft verschiedene Teile des Skripts Variablen mit demselben Namen verwenden. Indem Sie den Bereich auf den lokalen Kontext beschränken, definieren Sie die Grenzen des Codes, der auf eine Variable zugreifen kann, wodurch der Code robuster, modularer und einfacher zu debuggen ist.

Variablen mit globalem Gültigkeitsbereich werden als global bezeichnet, und Variablen mit lokalem Gültigkeitsbereich werden als lokal bezeichnet.

Hier ist ein Beispiel dafür, wie globale und lokale Variablen funktionieren.

"; ) sayHello(); echo "Wert von \$globalName: "$globalName"
"; echo "\$localName value: "$localName"
"; ?>

Hallo Harry! $globalName-Wert: „Zoe“ $localName-Wert: „“

In diesem Skript haben wir zwei Variablen erstellt:

  • $globalName- Das global Variable
  • $localName- Das lokal eine Variable, die innerhalb der Funktion sayHello() erstellt wird.

Nach dem Erstellen der Variablen und der Funktion ruft das Skript sayHello() auf, das „Hallo Harry!“ ausgibt. . Das Skript versucht dann, die Werte der beiden Variablen mithilfe der Echo-Funktion auszugeben. Folgendes passiert:

  • Als $globalName außerhalb der Funktion erstellt wurde, ist es überall im Skript verfügbar, daher wird „Zoe“ ausgegeben.
  • $localName ist nur innerhalb der Funktion sayHello() verfügbar. Da der Echo-Ausdruck außerhalb der Funktion liegt, bietet PHP keinen Zugriff auf die lokale Variable. Stattdessen erwartet PHP, dass der Code eine neue Variable namens $localName erstellt, die den Standardwert der leeren Zeichenfolge hat. Deshalb gibt der zweite Aufruf von echo den Wert „“ für die Variable $localName aus.

Zugriff auf globale Variablen innerhalb einer Funktion

Um auf eine globale Variable zuzugreifen außer Funktion Es reicht aus, einfach ihren Namen zu schreiben. Sondern um auf eine globale Variable zuzugreifen innerhalb einer Funktion, müssen Sie die Variable zunächst in der Funktion mit dem Schlüsselwort global als global deklarieren:

Funktion myFunction() ( global $globalVariable; // Auf die globale Variable $globalVariable zugreifen)

Wenn Sie dies nicht tun, geht PHP davon aus, dass Sie eine lokale Variable erstellen oder verwenden.

Hier ist ein Beispielskript, das eine globale Variable innerhalb einer Funktion verwendet:

"; global $globalName; echo "Hallo $globalName!
"; ) sayHello(); ?>

Bei der Ausführung gibt das Skript Folgendes aus:

Hallo Harry! Hallo Zoya!

Die Funktion sayHello() verwendet das Schlüsselwort global, um die Variable $globalName als global zu deklarieren. Sie kann dann auf die Variable zugreifen und deren Wert ausgeben („Zoe“).

Was sind Superglobale?

PHP verfügt über einen speziellen Satz vordefinierter globaler Arrays, die verschiedene Informationen enthalten. Solche Arrays werden aufgerufen Superglobale, da sie von überall im Skript aus zugänglich sind, einschließlich des internen Funktionsraums, und nicht mit dem Schlüsselwort global definiert werden müssen.

Hier ist eine Liste der Superglobals, die in PHP Version 5.3 verfügbar sind:

  • $GLOBALS – Liste aller globalen Variablen im Skript (außer Superglobals)
  • $_GET – enthält eine Liste aller Formularfelder, die vom Browser mithilfe einer GET-Anfrage übermittelt wurden
  • $_POST – enthält eine Liste aller Formularfelder, die vom Browser per POST-Anfrage gesendet werden
  • $_COOKIE – enthält eine Liste aller vom Browser gesendeten Cookies
  • $_REQUEST – enthält alle Schlüssel/Wert-Kombinationen, die in den Arrays $_GET, $_POST, $_COOKIE enthalten sind
  • $_FILES – enthält eine Liste aller vom Browser heruntergeladenen Dateien
  • $_SESSION – ermöglicht Ihnen das Speichern und Verwenden von Sitzungsvariablen für den aktuellen Browser
  • $_SERVER – enthält Informationen über den Server, wie z. B. den Dateinamen des ausgeführten Skripts und die IP-Adresse des Browsers.
  • $_ENV – enthält eine Liste von Umgebungsvariablen, die an PHP übergeben werden, z. B. CGI-Variablen.
Sie können beispielsweise $_GET verwenden, um die Werte von Variablen abzurufen, die in der Anforderungs-URL-Zeichenfolge eines Skripts enthalten sind, und sie auf der Seite anzuzeigen:

Wenn Sie das obige Skript mit der URL http://www.example.com/script.php?yourName=Fred ausführen, wird Folgendes ausgegeben:

Hallo Fred!

Warnung! In einem echten Skript sollte eine solche Datenübertragung aufgrund mangelnder Sicherheit niemals verwendet werden. Sie sollten Daten immer validieren oder filtern.

Der Superglobal $GLOBALS ist sehr praktisch zu verwenden, da er Ihnen ermöglicht, den Zugriff auf globale Variablen in einer Funktion zu organisieren, ohne dass das Schlüsselwort global erforderlich ist. Zum Beispiel:

"; ) sayHello(); // Gibt „Hallo, Zoya!“ aus ?>

Statische Variablen: Sie sind irgendwo in der Nähe

Wenn Sie eine lokale Variable innerhalb einer Funktion erstellen, existiert diese nur, während die Funktion ausgeführt wird. Wenn die Funktion abgeschlossen ist, verschwindet die lokale Variable. Bei einem erneuten Aufruf der Funktion wird eine neue lokale Variable erstellt.

In den meisten Fällen funktioniert das hervorragend. Somit sind die Funktionen in sich abgeschlossen und funktionieren bei jedem Aufruf immer gleich.

Es gibt jedoch Situationen, in denen es praktisch wäre, eine lokale Variable zu erstellen, die sich ihren Wert zwischen Funktionsaufrufen „merkt“. Eine solche Variable heißt statisch.

Um eine statische Variable in einer Funktion zu erstellen, müssen Sie das Schlüsselwort static vor dem Variablennamen verwenden und ihm unbedingt einen Anfangswert zuweisen. Zum Beispiel:

Funktion myFunction() ( static $myVariable = 0; )

Betrachten wir eine Situation, in der es praktisch ist, eine statische Variable zu verwenden. Nehmen wir an, Sie erstellen eine Funktion, die beim Aufruf ein Widget erstellt und die Anzahl der bereits erstellten Widgets anzeigt. Sie können versuchen, Code wie diesen mit einer lokalen Variablen zu schreiben:


"; echo createWidget() . " haben wir bereits erstellt.
"; echo createWidget() . " haben wir bereits erstellt.>
"; ?>

Da die Variable $numWidgets jedoch bei jedem Aufruf der Funktion erstellt wird, erhalten wir das folgende Ergebnis:

Wir erstellen einige Widgets... Wir haben bereits 1 erstellt. Wir haben bereits 1 erstellt. Wir haben bereits 1 erstellt.

Aber durch die Verwendung einer statischen Variablen können wir den Wert von einem Funktionsaufruf zu einem anderen speichern:

"; echo createWidget() . " haben wir bereits erstellt.
"; echo createWidget() . " haben wir bereits erstellt.
"; echo createWidget() . " >wir haben bereits erstellt.
"; ?>

Jetzt liefert das Skript das erwartete Ergebnis:

Wir erstellen einige Widgets... Wir haben bereits 1 erstellt. Wir haben bereits 2 erstellt. Wir haben bereits 3 erstellt.

Obwohl eine statische Variable ihren Wert zwischen Funktionsaufrufen behält, ist sie nur gültig, während das Skript ausgeführt wird. Sobald die Ausführung des Skripts abgeschlossen ist, werden alle statischen Variablen sowie lokale und globale Variablen zerstört.

Das ist alles! Bitte lesen Sie regelmäßig in Ihrer PHP-Dokumentation nach.

Hier ist zu beachten, dass das von Ihnen vorgestellte Codeelement als betrachtet werden sollte Schlechtes Design und schlechter Programmierstil, da die enthaltene Datei als sofort ausführbarer Satz von Vorgängen behandelt wird.

Der korrekteste Ansatz wäre, die Menge der Operationen als Funktionen/Klassen mit eigenem Namen in einer Datei abzulegen, die Datei einzubinden (ohne Return-Anweisung außerhalb der Funktionen) und dann die Funktion aufzurufen offensichtlich mit den erforderlichen Argumenten.

Also, was ist das Problem?

Alles ist ganz einfach, Sie machen es enthalten innerhalb einer Methode Methode, was bedeutet, dass die in der eingebundenen Datei angegebenen Variablen im Gültigkeitsbereich der Methode initialisiert werden Methode. Daher die Variable $lang ist nicht global und wird durch die Sichtbarkeit der Methode begrenzt, und Sie greifen auf eine globale Variable zu, wenn Sie also den Modifikator verwenden global es wird gleich null sein.

Wenn Sie sie in den globalen Bereich einbeziehen, wird die Variable lang öffentlich (global) und ihre Verwendung wird möglich. Dies lässt sich leicht überprüfen: Schreiben Sie einfach in die mitgelieferte Datei, bevor Sie mit der Definition einer Variablen beginnen globale $-Variable.

Beispiel:

Include „file1.php“; Funktion include2() ( include „file2.php“; )
  • file1.php ist im globalen Bereich definiert.
  • file2.php wird im lokalen Bereich der Funktion include2 definiert.

Der Ansatz mit globalen Variablen und solchen Include ist eine Krücke, die Ihnen in Zukunft Probleme bereiten wird. Funktionen müssen explizit definiert werden, einen eindeutigen Namen haben und bei Bedarf ausgeführt werden.

Warum ist der Ansatz mit globalen Variablen schlecht?

Der Punkt ist, dass globale Variablen von überall auf der Welt sichtbar sind. Das ist praktisch: Es gibt keine Einschränkungen. Andererseits wird es völlig unmöglich, nachzuverfolgen, wer die Daten ändert. Wenn man fragt, warum globale Variablen schlecht sind, kommt einem normalerweise als Erstes unkontrollierte Änderungen in den Sinn.

Nehmen wir an, Sie haben eine Funktion, deren Ergebnis von einer globalen Variablen abhängt. Sie rufen es auf, rufen es auf, aber nach 10 Minuten beginnt die Funktion, falsche Ergebnisse zurückzugeben. Was ist passiert? Schließlich übergeben Sie ihm denselben Parametersatz als Eingabe? Hmm, jemand hat den Wert einer globalen Variablen geändert ... Wer könnte es sein? Ja, jeder – schließlich steht eine globale Variable jedem zur Verfügung.

Das beste Rezept zum Entwerfen von Unterprogrammen ist: Lassen Sie das Ergebnis Ihrer Funktion nur von den Argumenten abhängen. Das ist ein anzustrebendes Ideal.

Verwenden Sie in Ihrem Projekt nicht unnötig globale Variablen Nutzen Sie alle Funktionen des lokalen Gültigkeitsbereichs und übergeben Sie Parameter an Funktionsargumente. Dadurch lässt sich der Code einfacher schreiben, warten und testen.

Wissen Sie, welches das beste Präfix für globale Variablen ist?

Innerhalb einer Unterroutine definierte Variablen (benutzerdefinierte Funktion). Sie sind nur innerhalb der Funktion zugänglich, in der sie definiert sind.

Bei PHP sind alle in einer Funktion deklarierten und verwendeten Variablen standardmäßig lokal für die Funktion. Das heißt, es ist standardmäßig nicht möglich, den Wert einer globalen Variablen im Hauptteil einer Funktion zu ändern.

Wenn Sie im Hauptteil einer benutzerdefinierten Funktion eine Variable verwenden, deren Name mit dem Namen einer globalen Variablen (die sich außerhalb der benutzerdefinierten Funktion befindet) identisch ist, hat diese lokale Variable keine Beziehung zur globalen Variablen. In dieser Situation wird in der benutzerdefinierten Funktion eine lokale Variable mit einem Namen erstellt, der mit dem Namen der globalen Variablen identisch ist, diese lokale Variable ist jedoch nur innerhalb dieser benutzerdefinierten Funktion verfügbar.

Lassen Sie uns diesen Sachverhalt anhand eines konkreten Beispiels erläutern:

$a = 100 ;

Funktion function() (
$a = 70 ;
Echo“

$a

" ;
}
Funktion();
Echo“

$a

" ;
?>

Das Skript gibt zuerst 70 und dann 100 aus:

70
100

Um diesen Nachteil zu beseitigen, gibt es in PHP eine spezielle Anweisung global, wodurch eine benutzerdefinierte Funktion mit globalen Variablen arbeiten kann. Schauen wir uns dieses Prinzip anhand konkreter Beispiele an:

$a = 1 ;
$b = 2 ;

Funktion Summe()
{
global $a, $b;

$b = $a + $b ;
}

Summe();
echo $b ;
?>

Das obige Skript gibt aus: 3 ". Nach der Definition $a Und $b innerhalb der Funktion wie global Alle Verweise auf eine dieser Variablen verweisen auf ihre globale Version. Es gibt keine Begrenzung für die Anzahl globaler Variablen, die von benutzerdefinierten Funktionen verarbeitet werden können.

Die zweite Möglichkeit, auf globale Bereichsvariablen zuzugreifen, besteht darin, ein spezielles PHP-definiertes Array zu verwenden $GLOBALS. Das vorherige Beispiel könnte wie folgt umgeschrieben werden:

Verwendung von $GLOBALS anstelle von global:

$a = 1 ;
$b = 2 ;

Funktion Summe()
{
$GLOBALS [ "b" ] = $GLOBALS [ "a" ] + $GLOBALS [ "b" ];
}

Summe();
echo $b ;
?>

$GLOBALS ist ein assoziatives Array, dessen Schlüssel der Name und dessen Wert der Inhalt der globalen Variablen ist. Beachten Sie, dass $GLOBALS in jedem Bereich vorhanden ist, da es sich um ein Array handelt. Nachfolgend finden Sie ein Beispiel, das die Fähigkeiten von Superglobals demonstriert:

Funktion test_global()
{
// Die meisten vordefinierten Variablen sind nicht vorhanden
// „super“ und lokal verfügbar sein
// Funktionssichtbarkeit erfordert die Angabe von „global“.
global $HTTP_POST_VARS ;

Echo $HTTP_POST_VARS["name"];

// Superglobals sind in jedem Bereich verfügbar
// Sichtbarkeit und erfordern nicht die Angabe von „global“.
// Superglobals verfügbar seit PHP 4.1.0
echo $_POST ["name" ];
}
?>



Verwandte Veröffentlichungen