Statische Variablen in PHP existieren nur innerhalb des Funktionsbereichs, das heißt, statische Variablen leben in PHP nur auf dem Stapel. Solange das Schlüsselwort static vor der Variablen hinzugefügt wird, wird die Variable zu einer statischen Variablen.
Die Betriebsumgebung dieses Artikels: Windows 7-System, PHP-Version 7.1, DELL G3-Computer
Was sind die statischen Variablen in der PHP-Methode?
Detaillierte Erläuterung statischer Variablen und der Verwendung statischer Variablen in PHP
Statische Variablen existieren nur innerhalb des Funktionsumfangs, d. h. statische Variablen leben nur auf dem Stapel. Im Allgemeinen werden Variablen innerhalb von Funktionen nach Funktionsende freigegeben, z. B. lokale Variablen, statische Variablen jedoch nicht. Das heißt, der Wert der Variablen bleibt beim nächsten Aufruf dieser Funktion erhalten.
Solange Sie das Schlüsselwort static vor einer Variablen hinzufügen, wird die Variable zu einer statischen Variablen.
<?php
function test()
{
static $nm = ;
$nm = $nm * ;
print $nm."<br />";
}
// 第一次执行，$nm =
test();
// 第一次执行，$nm =
test();
// 第一次执行，$nm =
test();
?>Ergebnisse der Programmausführung:
1
2
2
4
3
8
Nachdem die Funktion test() ausgeführt wurde, wird der Wert der Variablen $nm gespeichert.
Statische Eigenschaften werden häufig in Klassen verwendet, z. B. statische Mitglieder und statische Methoden.
Programmliste: Statische Mitglieder der Klasse
Die statische Variable $nm gehört zur Klasse nowamagic, nicht zu einer Instanz der Klasse. Diese Variable ist für alle Instanzen gültig.
:: ist der Bereichsbeschränkungsoperator. Der Bereich „self“ wird hier anstelle des Bereichs „$this“ verwendet. Der Bereich „$this“ repräsentiert nur die aktuelle Instanz der Klasse und self:: repräsentiert die Klasse selbst.
<?php
class nowamagic
{
public static $nm = ;
function nmMethod()
{
self::$nm += ;
echo self::$nm . '<br />';
}
}
$nmInstance = new nowamagic();
$nmInstance -> nmMethod();
$nmInstance = new nowamagic();
$nmInstance -> nmMethod();
?>Programmlaufergebnisse:
1
3
2
5
Programmliste: Statische Eigenschaften
<?php
class NowaMagic
{
public static $nm = 'www.nowamagic.net';
public function nmMethod()
{
return self::$nm;
}
}
class Article extends NowaMagic
{
public function articleMethod()
{
return parent::$nm;
}
}
// 通过作用于限定操作符访问静态变量
print NowaMagic::$nm . "<br />";
// 调用类的方法
$nowamagic = new NowaMagic();
print $nowamagic->nmMethod() . "<br />";
print Article::$nm . "<br />";
$nmArticle = new Article();
print $nmArticle->nmMethod() . "<br />";
?>Programmlaufergebnisse:
www.nowamagic.net
www.nowamagic.net
www.nowama gic. net
www.nowamagic.net
Programmliste: Einfacher statischer Konstruktor
PHP verfügt nicht über einen statischen Konstruktor. Möglicherweise müssen Sie eine statische Klasse initialisieren. Es gibt eine sehr einfache Methode. Rufen Sie direkt die Demonstration der Klasse auf nach der Klassendefinition ()-Methode.
<?php
function Demonstration()
{
return 'This is the result of demonstration()';
}
class MyStaticClass
{
//public static $MyStaticVar = Demonstration(); //!!! FAILS: syntax error
public static $MyStaticVar = null;
public static function MyStaticInit()
{
//this is the static constructor
//because in a function, everything is allowed, including initializing using other functions
self::$MyStaticVar = Demonstration();
}
} MyStaticClass::MyStaticInit(); //Call the static constructor
echo MyStaticClass::$MyStaticVar;
//This is the result of demonstration()
?>Ergebnis der Programmausführung:
Dies ist das Ergebnis von Demonstration()
Das Folgende ist eine Einführung in die Verwendung von statischen PHP-Variablen
Das Schlüsselwort static ist in der C#-Programmierung sehr verbreitet und wird zum Ändern von Deklarationen verwendet Ein statisches Mitglied, das zum Typ selbst und nicht zu einem bestimmten Objekt gehört. Der statische Modifikator kann für Klassen, Felder, Methoden, Eigenschaften, Operatoren, Ereignisse und Konstruktoren verwendet werden, jedoch nicht für Indexer, Destruktoren oder andere Typen als Klassen. Als statisch deklarierte Klassen, Funktionen und Variablen können nicht auf Instanzmethoden oder -variablen verweisen. Darüber hinaus müssen in C# alle darin enthaltenen Variablen und Methoden statisch sein, sobald der statische Modifikator zu einer Klasse hinzugefügt wird. Statische Variablen und Methoden müssen über Klassennamen und nicht über Instanzobjekte referenziert werden.
Was sind also die Unterschiede zwischen dem statischen Schlüsselwort in PHP und C#?
Deklarationsumfang
Im Vergleich zu C# ist der Anwendungsbereich statischer Variablen in PHP größer. Wir können nicht nur den statischen Modifikator vor einer Klasse, Methode oder Variablen hinzufügen, sondern sogar das Schlüsselwort static zum internen hinzufügen Variablen der Funktion. Der Wert einer Variablen mit dem hinzugefügten statischen Modifikator geht auch nach der Ausführung der Funktion nicht verloren. Das heißt, die Variable merkt sich beim nächsten Aufruf der Funktion weiterhin den ursprünglichen Wert. Zum Beispiel:
<?php
function test()
{
static $var=;
$var+=;
echo $var.' ';
}
test();
test();
test();
?>Die laufenden Ergebnisse lauten wie folgt:
3 5 7
Hier ist zu beachten, dass die Zuweisungsoperation der Variablen nur aufgerufen wird, wenn die Variable zum ersten Mal initialisiert wird Anschließende Ausführung der Funktion. Diese Operation wird nicht aufgerufen.
Da Funktionen in PHP im Gegensatz zu C# auch erstklassige Bürger sind, können wir Funktionen direkt definieren und sie direkt an einer beliebigen Stelle im Code aufrufen, was Javascript etwas ähnelt. Daher sind statische Funktionsvariablen derzeit nützlicher als die Definition globaler Variablen, wodurch Konflikte vermieden werden können, die durch wiederholte Definitionen von Variablen verursacht werden. Da Funktionen in C# nicht direkt definiert und aufgerufen werden können, müssen sie in einer Klasse gehostet werden. Wenn eine Funktion daher statische Variablen erfordert, müssen wir diese nur in der Klasse definieren, um den gleichen Effekt zu erzielen.
Methode aufrufen
In C# ist die Art und Weise, wie wir statische Mitglieder aufrufen, sehr einfach und konsistent, da statische Mitglieder nicht zu Instanzobjekten gehören. Unabhängig davon, ob es sich um eine Methode oder eine Variable handelt, greift C# immer über auf seine statischen Mitglieder zu der Klassenname .method (Variable). Und in C# können statische Funktionen nicht als virtuelle Methoden festgelegt oder überschrieben werden. PHP bietet hierfür eine flexiblere und vielfältigere Unterstützung.
Zuallererst wissen wir, dass Instanzmethoden in PHP über someobj->someFun() aufgerufen werden. Können wir also statische Funktionen wie C# über SomeClass->someFun() aufrufen? Die Antwort ist nein. In PHP können statische Member nur über :: aufgerufen werden, wie zum Beispiel SomeClass::someFun().
<?php
class TestC
{
public static $var=;
public $var=;
function t()
{
self::$var+=;
echo self::$var.' ';
echo $this->var.' ';
}
public static function t()
{
self::$var+=;
echo self::$var.' ';
}
}
$t=new TestC();
$t->t();
TestC::t();
?>Die laufenden Ergebnisse sind wie folgt:
3 1 5
Ein weiterer Unterschied zu C# besteht darin, dass wir in der Methode in der Klasse, wenn wir eine statische Variable aufrufen müssen, self: übergeben müssen: Die statische Variable $somVar (beachten Sie, dass das vorangehende $-Zeichen für Instanzvariablen nicht erforderlich ist) und der Aufruf einer statischen Methode ist self::someFun() (das $-Zeichen ist hier nicht erforderlich). Wie im obigen Beispiel.
另外，与C#最大的不同之处就是，PHP中，子类是可以覆盖父类的静态函数或变量的，不仅如此，(站在C#程序员的角度来看，我觉得PHP这点反而将事情搞复杂了)，由于默认self::staticFun()调用的是子类的静态函数，这个时候如果我们想调用父类的静态变量怎么办呢？这里PHP提供了额外的parent来调用基类的静态成员。如：
<?php
class TestC
{
public static $var=;
public $var=;
function t()
{
self::$var+=;
echo self::$var.' ';
echo $this->var.' ';
}
public static function t()
{
self::$var+=;
echo self::$var.' ';
}
}
$t=new TestC();
$t->t();
TestC::t();
?>运行结果如下：
3 5 ‘Hello'
最好，根据上面的例子我们很容易想到，子类访问父类可以使用parent关键字，那么父类如何访问子类的静态方法呢？这里给出static的另外一个用法，这里如果将调用的静态方法前面的作用域换成static的话，PHP会根据该类的继承层次来计算最终的静态方法。如：
<?php
class Test
{
function t()
{
static::t();
}
public static function t()
{
echo self::'Test ';
}
}
class Test extends Test
{
static function t()
{
echo self::'Test ';
}
}
$t=new Test();
$t->t();
Test::t();
?>运行结果如下：
Test2 Test2
这里t实例在t1方法调用t2静态方法时，会根据其实例找到最终的静态方法并输出Test2。
总结
从上面的分析，我们不难看出，对于静态成员的使用，PHP提供了比C#更为强大的功能或灵活性，但从我的角度来看，这种灵活性不见得就更好，从某种角度来看，如果类的继承层次过于复杂，它可能会让我产生混淆。当然，同样的工具不同人使用效果会完全不一样，既然PHP提供了更多样的选择，那么相信如果使用恰当的话，PHP中的static可能会提供比C#中更为强大而简便的使用方式。
推荐学习：《PHP视频教程》
Das obige ist der detaillierte Inhalt vonWas sind statische Variablen in PHP-Methoden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
So öffnen Sie eine PHP-Datei
So entfernen Sie die ersten paar Elemente eines Arrays in PHP
Was tun, wenn die PHP-Deserialisierung fehlschlägt?
So verbinden Sie PHP mit der MSSQL-Datenbank
So verbinden Sie PHP mit der MSSQL-Datenbank
So laden Sie HTML hoch
So lösen Sie verstümmelte Zeichen in PHP
So öffnen Sie PHP-Dateien auf einem Mobiltelefon
