Introduction to the use of PHP static variables_PHP tutorial

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 still remembers its original value the next time this function is called. Such as:

<?php
function test()
{
    static $var1=1;
    $var1+=2;
    echo $var1.'&nbsp';
}
test();
test();
test();
?> 

The running results are as follows:

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().

<?php
class TestC
{
    public static $var1=1;
    public $var2=1;
    function t1()
	{
        self::$var1+=2;
        echo self::$var1.'&nbsp';
        echo $this->var2.'&nbsp';
    }
    public static function t2()
	{
        self::$var1+=2;
        echo self::$var1.'&nbsp';
    }
}
$t=new TestC();
$t->t1();
TestC::t2(); 
?>

The running results are as follows:

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 is (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:

<?php
class Test1
{
    public static $var1=1;
    public static function t2()
	{
        self::$var1+=2;
        echo self::$var1.'&nbsp';
    }
}
class Test2 extends Test1
{
    static $var1=‘Hello’;
    static function t2()
	{
        parent::t2();
        echo self::$var1.'&nbsp';
    }
}
Test1::t2();
Test2::t2();
?> 

The running results are as follows:

Best, based on the above example we can easily think that a subclass can use the parent keyword to access the parent class. So how does the parent class access the static method of the subclass? Here is another usage of static. If the scope in front of the called static method is changed to static, PHP will calculate the final static method based on the inheritance hierarchy of the class. Such as:

<?php
class Test1
{
    function t1()
	{
        static::t2();
    }
    public static function t2()
	{
        echo self::'Test1&nbsp';
    }
}
class Test2 extends Test1
{
    static function t2()
	{
        echo self::'Test2&nbsp';
    }
}
$t=new Test2();
$t->t1();
Test2::t2();
?> 

The running results are as follows:

Here, when the t instance calls the t2 static method from the t1 method, it will find the final static method based on its instance and output Test2.

Summary

From the above analysis, it is not difficult to see that PHP provides more powerful functions or flexibility than C# for the use of static members, but from my perspective, this flexibility is not necessarily better. , from a certain point of view, it might confuse me if the class inheritance hierarchy is too complex. Of course, the same tool will have completely different effects when used by different people. Since PHP provides more choices, I believe that if used appropriately, static in PHP may provide a more powerful and easier way to use than in C#.