Haftungsausschluss: Dieser Artikel offenbart Ihnen keinerlei Offenbarung und öffnet nicht das dritte Auge, sondern ermöglicht es Ihnen, die nicht so offensichtliche Frage genauer zu verstehen. Zumindest als ich es schrieb, half sie mir dabei. Wenn Sie ein erfahrener Wolf in PHP sind, dann können Sie es nicht lesen. Ich denke, es wird erfahrenen Menschen nicht schaden, durch ihre Augen zu rennen, sie sozusagen im Gedächtnis aufzufrischen, der Rest wird normal sein.
Also ...
Statische Variablen in PHP sind eine spezielle Art von Variablen, die mit dem Schlüsselwort static deklariert werden .
static $foo = 3;
Sie unterscheiden sich von gewöhnlichen Variablen darin (später in diesem Artikel werden diese Punkte genauer betrachtet):
- Es können nur Konstanten und konstante Ausdrücke zugewiesen werden
- Die Lebensdauer einer statischen Variablen ist nicht auf die Lebensdauer des Bereichs beschränkt, in dem sie deklariert wurde
- kann nur einmal im Skript definiert werden
- erst am Ende des Skripts zerstört
Jetzt in Ordnung.
1. Es können nur Konstanten und konstante Ausdrücke zugewiesen werden
Dies bedeutet, dass das Ergebnis der Operation einer Funktion oder Methode keiner statischen Variablen oder im Allgemeinen allem zugewiesen werden kann, was in der Kompilierungsphase noch nicht bekannt ist. Das heißt, eine solche Anzeige funktioniert nicht
static $var = foo();
aber es ist durchaus möglich
static $var = 'some str'; static $varInt = 3 + 5;
2. Die Lebensdauer einer statischen Variablen ist nicht auf die Lebensdauer des Bereichs beschränkt, in dem sie deklariert ist
Ich werde versuchen zu erklären, was ich hier gemeint habe. Vielleicht werde ich einige Ungenauigkeiten in der Terminologie machen, aber ich werde versuchen, die Essenz so genau wie möglich zu vermitteln. Vergleiche mit einer regulären Variablen. Wenn eine Variable innerhalb einer Funktion deklariert wird, handelt es sich standardmäßig um eine lokale Variable, dh sie wird im lokalen Bereich (Bereich dieser Funktion) deklariert. In diesem Fall ist der Kontext dieser Funktion der lokale Bereich. Nachdem die Funktion funktioniert und das Ergebnis zurückgegeben hat, wird ihr Bereich oder ihr Kontext mit allen darin enthaltenen Variablen zerstört.
Wenn wir eine statische Variable innerhalb der Funktion deklarieren, wird sie auch im lokalen Bereich deklariert, aber ihr Kontext ist nicht der lokale Bereich, sondern die Funktion selbst.
(Ferner, der schwierigste Moment zu erklären, übergebe ich nur die Essenz ohne Details, wie Funktionen in PHP deklariert werden, wie viel Speicher ihnen zugewiesen ist und was in diesem Speicher liegt). Es stellt sich heraus, dass der Interpreter beim Aufrufen einer Funktion einen lokalen Bereich dafür erstellt. Darin werden alle lokalen Variablen und Funktionen deklariert und hinsichtlich ihres Kontexts daran angehängt. Durch Deklarieren einer Variablen im lokalen Bereich mit static wird die Funktion selbst dieser Variablen als Kontext zugewiesen, und diese Variable bleibt bestehen, solange die Funktion selbst vorhanden ist. Dies ist so etwas wie js, wenn eine Funktion ein Objekt ist, dem Sie beliebige Eigenschaften und Methoden zuweisen können. Auch hier ist nur eine Funktion in PHP ein Objekt nicht für PHP, sondern für eine niedrigere Sprache.
function echoStaticVar() { static $var = 0; $var++; var_dump($var); }; echoStaticVar();
Es ist ersichtlich, dass der Kollektor nach Beendigung der Funktion die Variable $ var nicht wie bei einer regulären Variablen zerstört.
Und hier ist ein Beispiel, das deutlich zeigt, dass eine statische Variable zu einer Funktion gehört (entweder ist sie in einer Funktion gespeichert oder ihr Kontext ist eine Funktion. Es tut mir leid, dass ich nicht weiß, wie ich sie richtig benennen soll).
$one = function ($i) { static $var = 0; $var += $i; var_dump($var); }; $two = $one; $one(1);
Alles funktioniert wie erwartet, denn wenn $ zwei = $ eins zugewiesen wird; Die Funktion selbst wird nicht kopiert, aber diese beiden Variablen beziehen sich einfach auf denselben Speicherbereich. Dementsprechend ist die statische Variable $ var sowohl für $ eins als auch für $ zwei eins
Wir ändern das Beispiel ein wenig, nämlich wir weisen es nicht zu, aber wir klonen
$one = function ($i) { static $var = 0; $var += $i; var_dump($var); }; $two = clone($one); $one(1);
Nun stellte sich heraus, dass $ one und $ two nicht auf dieselbe Funktion mit einer statischen Variablen $ var verweisen, sondern auf zwei verschiedene Funktionen, die in unterschiedlichen Speicherbereichen liegen und jeweils eine eigene statische Variable $ var haben. Dies ist kein besonders offensichtlicher Punkt, daher können Sie darauf stoßen, wenn Sie Code in einem prozeduralen Stil schreiben, der wahrscheinlich bereits als schlechte Form angesehen wird, aber nicht korrekt ist.
Was Sie damit machen können, ist ein klassisches Beispiel für einen Funktionsaufrufzähler.
Aber im Zusammenhang mit der Verbreitung von OOP in dieser Form sind statische Variablen selten, da Sie grundsätzlich mit Klassen und Methoden arbeiten müssen (ich werde einen separaten Artikel über die Implementierung von statischen in ihnen schreiben).
3. kann im Skript nur einmal definiert werden
Dies bedeutet, dass wenn eine statische Variable bereits deklariert ist und ihr ein Wert zugewiesen wurde, nachfolgende Zuweisungen den bereits zugewiesenen Wert nicht überschreiben, sondern den vorhandenen zurückgeben.
function staticVar($i) { static $var = 0; $var += $i; var_dump($var); }; staticVar(1);
Es ist ersichtlich, dass wenn die statische Variable $ var jedes Mal einen neu zugewiesenen Wert hätte, wir immer das Ergebnis 1 erhalten würden. Da es jedoch bei der Neuzuweisung nicht neu geschrieben wird, erhalten wir das, was wir erhalten.
Es stimmt, es gibt eine Sache, die alles ruinieren kann. Im Rahmen einer Funktion (genauer gesagt beim ersten Aufruf der Funktion) kann eine solche Variable beliebig oft umgeschrieben werden (in den folgenden Fällen funktioniert alles wie angegeben). Dieses Verhalten kam mir seltsam und lustig vor, besonders wenn man mit Beispielen herumspielt.
function staticVar($i) { static $var = 0; static $var = 5; $var += $i; var_dump($var); }; staticVar(1);
Hier wurde die Variable $ var im ersten Aufruf der staticVar- Funktion in der ersten Zeile zugewiesen und in der zweiten Zeile überschrieben. Aber bereits in weiteren Anrufen, weder in der ersten noch in der zweiten Zeile, wurde sie neu zugewiesen, sondern gab zurück, was bereits im vorherigen Anruf war
function staticVar($i) { static $var = 0;
Noch seltsamer beim ersten Aufruf von staticVar in der ersten Zeile wurde es zugewiesen, dann wurde es in der zweiten Zeile neu zugewiesen (aber erfolglos), dann wurde eine Additionsaktion damit ausgeführt, und danach wurde beim Versuch, es sogar innerhalb des ersten Funktionsaufrufs neu zuzuweisen, die bereits vorhandene zurückgegeben ihre Bedeutung.
function staticVarWrong($i) { static $var = 0; static $var = 5; $var += $i; var_dump($var); };
Das heißt, es stellt sich in fast den gleichen Methoden heraus, unterschiedliches Verhalten. Basierend auf der Beschreibung, wie sich statische Variablen verhalten sollen, wird in staticVarRight das richtige Ergebnis erzielt. In staticVarWrong stellt sich (basierend auf dem Verhalten der Funktion) heraus, dass in der zweiten Zeile der Funktion die Variable neu definiert wurde.
Das hat mich ziemlich amüsiert.
4. werden erst am Ende des Skripts zerstört
Ich sehe nicht viel Sinn darin, diesen Punkt zu erklären, zumal aus den Beispielen alles klar hervorgeht. Während das Skript ausgeführt wird und eine Funktion vorhanden ist, für die eine statische Variable deklariert ist, ist diese Variable vorhanden.
Wie geplant ist dies der erste Artikel über statische , vor OOP, statische Felder und Methoden.
Nun, natürlich, wenn es zumindest jemand ist, wird er interessiert und nicht schwer zu beschuldigen sein.