Les variables statiques en PHP n'existent que dans le cadre de la fonction, c'est-à-dire que les variables statiques ne vivent que sur la pile ; en PHP, tant que le mot-clé static est ajouté avant la variable, la variable devient une variable statique.
L'environnement d'exploitation de cet article : système Windows 7, PHP version 7.1, ordinateur DELL G3
Quelles sont les variables statiques dans la méthode php ?
Explication détaillée des variables statiques et utilisation des variables statiques en PHP
Les variables statiques n'existent que dans le cadre de la fonction, c'est-à-dire que les variables statiques ne vivent que sur la pile. Généralement, les variables contenues dans les fonctions seront publiées après la fin de la fonction, comme les variables locales, mais pas les variables statiques. C’est-à-dire que la valeur de la variable sera conservée au prochain appel de cette fonction.
Tant que vous ajoutez le mot-clé static avant une variable, la variable devient une variable statique.
<?php
function test()
{
static $nm = ;
$nm = $nm * ;
print $nm."<br />";
}
// 第一次执行，$nm =
test();
// 第一次执行，$nm =
test();
// 第一次执行，$nm =
test();
?>Résultats d'exécution du programme :
1
2
2
4
3
8
Après l'exécution de la fonction test(), la valeur de la variable $nm est enregistrée.
Les propriétés statiques sont souvent utilisées dans les classes, telles que les membres statiques et les méthodes statiques.
Liste des programmes : membres statiques de la classe
La variable statique $nm appartient à la classe nowamagic, pas à une instance de la classe. Cette variable est valable pour toutes les instances.
:: est l'opérateur de limitation de portée. La portée self est utilisée ici à la place de la portée $this. La portée $this ne représente que l'instance actuelle de la classe, et self:: représente la classe elle-même.
<?php
class nowamagic
{
public static $nm = ;
function nmMethod()
{
self::$nm += ;
echo self::$nm . '<br />';
}
}
$nmInstance = new nowamagic();
$nmInstance -> nmMethod();
$nmInstance = new nowamagic();
$nmInstance -> nmMethod();
?>Résultats en cours d'exécution du programme :
1
3
2
5
Liste des programmes : propriétés statiques
<?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 />";
?>Résultats en cours d'exécution du programme :
www.nowamagic.net
www.nowamagic.net
www.nowamagic. net
www.nowamagic.net
Liste des programmes : Constructeur statique simple
PHP n'a pas de constructeur statique, vous devrez peut-être initialiser une classe statique, il existe une méthode très simple, appelez directement la démonstration de la classe après la méthode de définition de classe ().
<?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()
?>Résultat de l'exécution du programme :
Ceci est le résultat de la démonstration()
Ce qui suit est une introduction à l'utilisation des variables statiques PHP
Le mot-clé statique est très courant dans la programmation C#, il est utilisé pour modifier les déclarations Membre statique qui appartient au type lui-même plutôt qu'à un objet spécifique. Le modificateur static peut être utilisé sur les classes, les champs, les méthodes, les propriétés, les opérateurs, les événements et les constructeurs, mais pas sur les indexeurs, les destructeurs ou les types autres que les classes. Les classes, fonctions et variables déclarées comme statiques ne pourront pas référencer des méthodes ou des variables d'instance. De plus, en C#, une fois le modificateur static ajouté à une classe, toutes les variables et méthodes qu'elle contient doivent être statiques. Les variables et méthodes statiques doivent être référencées via des noms de classe et non via des objets d'instance.
Alors quelles sont les différences entre le mot-clé static en PHP et C# ?
Portée de la déclaration
Par rapport à C#, la portée d'utilisation des variables statiques en PHP est plus large. Non seulement nous pouvons ajouter le modificateur static devant une classe, une méthode ou une variable, mais nous pouvons même ajouter le mot-clé static au mot-clé interne. variables de la fonction. La valeur d'une variable avec le modificateur statique ajouté ne sera pas perdue même après l'exécution de la fonction, c'est-à-dire que la variable se souvient toujours de sa valeur d'origine la prochaine fois que cette fonction est appelée. Par exemple :
<?php
function test()
{
static $var=;
$var+=;
echo $var.' ';
}
test();
test();
test();
?>Les résultats d'exécution sont les suivants :
3 5 7
Une chose à noter ici est que l'opération d'affectation de la variable ne sera appelée que lorsque la variable est initialisée pour la première fois. exécution ultérieure de la fonction, Cette opération ne sera pas appelée.
Étant donné que les fonctions en PHP sont également des citoyens de premier ordre, contrairement à C#, nous pouvons définir directement des fonctions et les appeler directement n'importe où dans le code, ce qui est un peu similaire au javascript. Par conséquent, à l'heure actuelle, les variables statiques de fonction sont plus utiles que la définition de variables globales, ce qui peut éviter les conflits causés par des définitions répétées de variables. Étant donné que les fonctions en C# ne peuvent pas être directement définies et appelées, elles doivent être hébergées dans une classe. Par conséquent, si une fonction nécessite des variables statiques, il suffit de les définir dans la classe pour obtenir le même effet.
Méthode d'appel
En C#, la façon dont nous appelons les membres statiques est très simple et cohérente, car les membres statiques n'appartiennent pas à des objets d'instance, donc qu'il s'agisse d'une méthode ou d'une variable, C# accède toujours à ses membres statiques via le nom de la classe .method (variable). Et en C#, les fonctions statiques ne peuvent pas être définies comme méthodes virtuelles ou remplacées. PHP fournit un support plus flexible et diversifié pour cela.
Tout d'abord, nous savons que l'appel de méthodes d'instance en PHP est appelé via someobj->someFun(), pouvons-nous donc appeler des fonctions statiques via SomeClass->someFun() comme C# ? La réponse est non. En PHP, l'appel de membres statiques ne peut être effectué que via ::, tel que : 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();
?>Les résultats d'exécution sont les suivants :
3 1 5
Un autre point différent du C# est que dans la méthode de la classe, si nous devons appeler une variable statique, nous devons passer le self :: Variable statique $somVar (notez la variable Le signe $ devant n'est pas requis pour les variables d'instance), et l'appel d'une méthode statique est self::someFun() (le signe $ n'est pas requis ici). Comme dans l'exemple ci-dessus.
另外，与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视频教程》
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Comment ouvrir le fichier php
Comment supprimer les premiers éléments d'un tableau en php
Que faire si la désérialisation php échoue
Comment connecter PHP à la base de données mssql
Comment connecter PHP à la base de données mssql
Comment télécharger du HTML
Comment résoudre les caractères tronqués en PHP
Comment ouvrir des fichiers php sur un téléphone mobile
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
