Analyse sur l'utilisation des variables statiques et des variables statiques en PHP

Cet article principalement Cet article présente les variables statiques en PHP et des informations détaillées sur l'utilisation des variables statiques. Les amis dans le besoin peuvent se référer à

Les variables statiques n'existent que dans la portée 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 le mot clé static est ajouté avant la variable, la variable devient une variable statique.

<?php
  function test()
  {
    static $nm = ;
    $nm = $nm * ;
    print $nm."<br />";
  }
  // 第一次执行，$nm = 
  test();
  // 第一次执行，$nm = 
  test();
  // 第一次执行，$nm = 
  test();
?>

Résultat en cours 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 attributs statiques sont souvent utilisés dans les classes, tels 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 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 . &#39;<br />&#39;;
    }
  }
  $nmInstance = new nowamagic();
  $nmInstance -> nmMethod();
  $nmInstance = new nowamagic();
  $nmInstance -> nmMethod();
?>

Résultat de l'exécution du programme :
1
3
2
5

Liste des programmes : attributs statiques

<?php
  class NowaMagic
  {
    public static $nm = &#39;www.nowamagic.net&#39;;
    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ésultat 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 un moyen très simple d'appeler la méthode Demonstration() de la classe directement après la définition de la classe.

<?php
function Demonstration()
{
  return &#39;This is the result of demonstration()&#39;;
}
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()

donné ci-dessous Introduisons l'utilisation des variables statiques PHP

Le mot-clé static est très courant dans la programmation C#. Il est utilisé comme modificateur pour déclarer des membres statiques qui appartiennent 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 en 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 des modificateurs statiques devant les classes, méthodes ou variables, mais nous pouvons même ajouter. le mot-clé static aux variables internes 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.&#39; &#39;;
}
test();
test();
test();
?>

Les résultats en cours d'exécution sont les suivants :

3 5 7

Là est quelque chose à noter ici. Ce qui est intéressant, c'est que l'opération d'affectation de variable ne sera appelée que lorsque la variable est initialisée pour la première fois. Cette opération ne sera pas appelée lors des exécutions ultérieures de la fonction.

É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 à 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 s'il s'agit de méthodes ou variables, C# L'accès à ses membres statiques se fait toujours via le nom de 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 les méthodes d'instance en PHP sont appelées 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.&#39; &#39;;
    echo $this->var.&#39; &#39;;
  }
  public static function t()
  {
    self::$var+=;
    echo self::$var.&#39; &#39;;
  }
}
$t=new TestC();
$t->t();
TestC::t();
?>

Les résultats en cours d'exécution sont les suivants :

3 1 5

Un autre point est différent See More depuis C# Oui, dans la méthode de la classe, si nous devons appeler une variable statique, nous devons passer la variable statique self::$somVar (notez le signe $ devant la variable, les variables d'instance ne sont pas obligatoires), et appeler une méthode statique est self::someFun() (aucun signe $ 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.&#39; &#39;;
    echo $this->var.&#39; &#39;;
  }
  public static function t()
  {
    self::$var+=;
    echo self::$var.&#39; &#39;;
  }
}
$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::&#39;Test &#39;;
  }
}
class Test extends Test
{
  static function t()
  {
    echo self::&#39;Test &#39;;
  }
}
$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的用法

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!