Heim > Artikel > Backend-Entwicklung > Analyse zur Verwendung statischer Variablen und statischer Variablen in PHP
Dieser Artikel hauptsächlich In diesem Artikel werden statische Variablen in PHP vorgestellt und detaillierte Informationen zur Verwendung statischer Variablen bereitgestellt.
Statische Variablen existieren nur innerhalb des Funktionsbereichs, das heißt, 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 das Schlüsselwort static vor der Variablen hinzugefügt wird, wird die Variable zu einer statischen Variablen.
<?php
function test()
{
static $nm = ;
$nm = $nm * ;
print $nm."<br />";
}
// 第一次执行，$nm =
test();
// 第一次执行，$nm =
test();
// 第一次执行，$nm =
test();
?>
Ergebnis 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();
?>
Programmlaufergebnis:
1
3
2
5
Programmliste: Statische Attribute
<?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 />";
?>
Programmlaufergebnis:
www.nowamagic.net
www.nowamagic. net
www.nowamagic.net
www.nowamagic.net
Programmliste: Einfacher statischer Konstruktor
PHP hat keinen statischen Konstruktor, Sie Möglicherweise müssen Sie eine statische Klasse initialisieren. Es gibt eine sehr einfache Methode, die Demonstration()-Methode der Klasse direkt nach der Klassendefinition aufzurufen.
<?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 ein Einführung für Sie Einführung in die Verwendung statischer PHP-Variablen
Das Schlüsselwort static ist in der C#-Programmierung sehr verbreitet. Es wird als Modifikator verwendet, um statische Mitglieder zu deklarieren, die zum Typ selbst und nicht zu a gehören bestimmtes Objekt. 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 Schlüsselwort static in PHP und C#?
Deklarationsumfang
Im Vergleich zu C# ist der Anwendungsbereich statischer Variablen in PHP größer. Wir können nicht nur statische Modifikatoren vor Klassen, Methoden oder Variablen hinzufügen, sondern sogar hinzufügen das Schlüsselwort static für die internen 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 dieser Funktion weiterhin ihren ursprünglichen Wert. Zum Beispiel:
<?php
function test()
{
static $var=;
$var+=;
echo $var.' ';
}
test();
test();
test();
?>
Die Laufergebnisse lauten wie folgt:
3 5 7
Eine Sache zu Beachten Sie hier, dass die Variablenzuweisungsoperation nur aufgerufen wird, wenn die Variable zum ersten Mal initialisiert wird. Diese Operation wird bei nachfolgenden Funktionsausführungen 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, also ob es sich um Methoden handelt oder Variablen, C#-Zugriff auf seine statischen Mitglieder erfolgt immer über Klassenname.Methode (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 über SomeClass->someFun() wie C# aufrufen? Die Antwort ist nein. In PHP kann der Aufruf statischer Member nur über :: erfolgen, 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 Wenn wir in der Methode in der Klasse eine statische Variable aufrufen müssen, müssen wir die statische Variable self::$somVar übergeben (beachten Sie das $-Symbol vor der Variablen, Instanzvariablen sind nicht erforderlich) und eine statische Variable aufrufen Methode ist self::someFun()( Hier ist kein $-Zeichen 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中文网！
相关推荐：
关于PHP中addcslashes与stripcslashes的函数解析
关于PHP模板引擎Smarty内建函数section和sectionelse的用法
Das obige ist der detaillierte Inhalt vonAnalyse zur Verwendung statischer Variablen und statischer Variablen in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!