Detailed explanation of static variables in PHP and the use of static static variables, detailed explanation of the use of static

Detailed explanation of static variables in PHP and the use of static static variables, detailed explanation of the use of static_PHP tutorial

WBOY

Release： 2016-07-12 09:05:28

Original

817 people have browsed it

Detailed explanation of static variables in PHP and the use of static static variables. Detailed explanation of the use of static

Static variables only exist within the function scope, that is to say, static variables only live on the stack . Generally, variables within functions will be released after the function ends, such as local variables, but static variables will not. That is to say, the value of the variable will be retained the next time this function is called.

As long as you add the keyword static before a variable, the variable becomes a static variable.

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

Copy after login

Program execution result:
1
2
2
4
3
8

After the function test() is executed, the value of the variable $nm is saved.

Static attributes are often used in classes, such as static members and static methods.

Program List: Static members of the class

The static variable $nm belongs to the class nowamagic, not to an instance of the class. This variable is valid for all instances.

:: is the scope qualification operator. The self scope is used here instead of the $this scope. The $this scope only represents the current instance of the class, and self:: represents the class itself.

<&#63;php
  class nowamagic
  {
    public static $nm = ;
    function nmMethod()
    {
      self::$nm += ;
      echo self::$nm . '<br />';
    }
  }
  $nmInstance = new nowamagic();
  $nmInstance -> nmMethod();
  $nmInstance = new nowamagic();
  $nmInstance -> nmMethod();
&#63;>

Copy after login

Program execution result:
1
3
2
5

Program List: Static properties

<&#63;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 />";
&#63;>

Copy after login

Program execution result:

www.nowamagic.net
www.nowamagic.net
www.nowamagic.net
www.nowamagic.net

Program List: Simple static constructor

PHP does not have a static constructor. You may need to initialize a static class. There is a very simple method. Call the Demonstration() method of the class directly after the class definition.

<&#63;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()
&#63;>

Copy after login

Program execution result:

This is the result of demonstration()

The following is an introduction to the use of PHP static variables

The static keyword is very common in C# programming. It is used to modify the declaration of static members that belong to the type itself rather than to a specific object. The static modifier can be used on classes, fields, methods, properties, operators, events, and constructors, but not on indexers, destructors, or types other than classes. Classes, functions and variables declared as static will not be able to reference instance methods or variables. In addition, in C#, once the static modifier is added to a class, all variables and methods inside it must be static. Static variables and methods must be referenced through class names and not through instance objects.

So what are the differences between the static keyword in PHP and C#?

Declaration scope

Compared to C#, the scope of use of static variables in PHP is wider. Not only can we add the static modifier in front of a class, method or variable, we can even add the static keyword to the internal variables of the function. The value of a variable with the static modifier added will not be lost even after the function is executed. That is to say, the variable will still remember the original value the next time the function is called. Such as:

<&#63;php
function test()
{
  static $var=;
  $var+=;
  echo $var.' ';
}
test();
test();
test();
&#63;>

Copy after login

The running results are as follows:

3 5 7

One thing to note here is that the variable assignment operation will only be called when the variable is initialized for the first time. This operation will not be called during subsequent function executions.

Since functions in PHP are also first-class citizens, unlike C#, we can directly define functions and call them directly anywhere in the code, which is somewhat similar to JavaScript. Therefore, at this time, function static variables are more useful than defining global variables, which can avoid conflicts caused by repeated definitions of variables. Since functions in C# cannot be directly defined and called, they must be hosted in a class. Therefore, if a function requires static variables, we only need to define them in the class to achieve the same effect.

Calling method

In C#, the way we call static members is very simple and consistent, because static members do not belong to instance objects, so whether it is a method or a variable, the way C# accesses its static members is always through the class name.Method (variable) conduct. And in C#, static functions cannot be set as virtual methods or overridden. PHP provides more flexible and diverse support for this.

First of all, we know that instance methods in PHP are called through someobj->someFun(), so can we call static functions through SomeClass->someFun() like C#? The answer is no. In PHP, calling static members can only be done through ::, such as: SomeClass::someFun().

<&#63;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();
&#63;>

Copy after login

The running results are as follows:

3 1 5

Another point that is different from C# is that in a method in a class, if we need to call a static variable, we must pass the self::$somVar static variable (note the $ sign in front of the variable, instance variables are not required), and Calling a static method is self::someFun() (no $ sign is needed here). As in the above example.

In addition, the biggest difference from C# is that in PHP, subclasses can override the static functions or variables of the parent class. Not only that, (from the perspective of a C# programmer, I think this (On the contrary, it complicates things). Since self::staticFun() calls the static function of the subclass by default, what should we do if we want to call the static variable of the parent class at this time? Here PHP provides additional parents to call static members of the base class. Such as:

<&#63;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();
&#63;>

Copy after login

运行结果如下：

3 5 ‘Hello'

最好，根据上面的例子我们很容易想到，子类访问父类可以使用parent关键字，那么父类如何访问子类的静态方法呢？这里给出static的另外一个用法，这里如果将调用的静态方法前面的作用域换成static的话，PHP会根据该类的继承层次来计算最终的静态方法。如：

<&#63;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();
&#63;>

Copy after login

运行结果如下：

Test2 Test2

这里t实例在t1方法调用t2静态方法时，会根据其实例找到最终的静态方法并输出Test2。

总结

从上面的分析，我们不难看出，对于静态成员的使用，PHP提供了比C#更为强大的功能或灵活性，但从我的角度来看，这种灵活性不见得就更好，从某种角度来看，如果类的继承层次过于复杂，它可能会让我产生混淆。当然，同样的工具不同人使用效果会完全不一样，既然PHP提供了更多样的选择，那么相信如果使用恰当的话，PHP中的static可能会提供比C#中更为强大而简便的使用方式。