Quelles sont les fonctions des variables statiques en PHP

Cet article présente principalement le rôle des variables statiques en PHP. Les amis intéressés peuvent s'y référer. J'espère qu'il sera utile à tout le monde.

Manuel recommandé :Manuel d'auto-apprentissage complet php

Les variables statiques n'existent que dans le cadre de la fonction, c'est-à-dire, variables statiques uniquement Live sur la pile.

Les variables générales au sein des fonctions seront publiées après la fin de la fonction, telles que 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ésultats de l'exécution du programme :

1
2
2
4
3
8

Une fois la fonction test() exécutée, 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.

Articles connexes recommandés :
1.Quand les variables statiques php sont-elles détruites
2.Quelles sont les différences entre les variables statiques et les variables globales en PHP ?
Recommandations vidéo associées :
1.Tutoriel vidéo Dugu Jiujian (4)_PHP

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 de l'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. la classe Appelez directement la méthode Demonstration() de la classe après la définition.

<?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ésultats de l'exécution du programme :

This is the result of demonstration()

Ce qui suit est une introduction à l'utilisation des variables statiques PHP static

mot-clé statique dans C# Très courant en programmation, il est utilisé comme modificateur pour déclarer des membres statiques appartenant 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, une fois le modificateur statique ajouté à une classe en C#, 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. Nous pouvons non seulement ajouter le modificateur statique devant une classe, une méthode ou une variable. , 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();
?>

Le résultat d'exécution est le suivant :

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, 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.

Comme les fonctions en C# ne peuvent pas être directement définies et appelées, elles doivent être hébergées dans une classe, donc si la 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 l'appel de méthodes d'instance en PHP est appelé via :

someobj->someFun(), pouvons-nous donc appeler des fonctions statiques via SomeClass-> comme C# ? Qu’en est-il des appels someFun() ?

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

另外一点和C#中不同的是，在类中的方法中，如果我们需要调用静态变量，必须通过self::$somVar静态变量(注意变量前面的$符号,实例变量不需要)，而调用静态方法则为self::someFun()(这里不需要$符号)。如上例。

另外，与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中数组处理函数的功能

PHP获取目录下文件

PHP中each及list函数的使用技巧

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!