Detailed explanation of the usage and precautions of the static keyword in PHP

PHP static keyword is used to define static methods and properties, which can be used to delay static binding in classes and modify them in functions variable.

1: Let’s first talk about the use of static in functions;

function add(){
	static $a = 0;
	echo $a,"<br />";
	$a++;
}

The role of static here is similar to the role of static in C. It ensures that the $a variable will only be initialized when add() is called for the first time, but it should be noted that defining static variables When assigning an initial value, you do not need to assign an initial value or you can give an initial value. However, when assigning an initial value, you cannot use expression or call a function to assign a value, otherwise an error will be reported.

Another thing to note is that static variables will not store references, as follows:

function get_obj_ref(){
	 static $obj = null;
	 echo &#39;Ststic obj:&#39;,"<br />";
	 var_dump($obj);
	 if(is_null($obj)){
		 $obj = &new stdClass();
	 }
	 return $obj;
	 
 }
 $obj = get_obj_ref();
 $obj2 = get_obj_ref();
 
 function get_obj_noref(){
	 static $obj = null;
	 echo &#39;Ststic obj:&#39;,"<br />";
	 var_dump($obj);
	 if(is_null($obj)){
		 $obj = new stdClass();
	 }
	 return $obj;
 }
 $obj = get_obj_noref();
 $obj2 = get_obj_noref();

When static is stored When quoting, the value of the variable is not saved after calling the function a second time, and a Deprecated error will be reported when running the above program, that is, the usage of return reference value assignment has been abandoned.

2: Delayed static binding of static in the class;

Delayed static Binding refers to allowing the called class to be referenced in the context of a static inheritance. Delayed binding means: static:: is no longer the class in which the current method is defined, but the class in which it is actually run. Note: It can be used for (but not limited to) static method calls.

In addition to the simple static delayed binding usage, there is also a forward call, that is, using self::, parent::, static:: and forward_static_call( ) (This function can only be called in a method) will forward the calling information, as follows:

##

class A {
    public static function foo() {
        static::who();
    }

    public static function who() {
        echo CLASS."\n";
    }
}

class B extends A {
    public static function test() {
        A::foo();
        parent::foo();
        self::foo();
    }

    public static function who() {
        echo CLASS."\n";
    }
}
class C extends B {
    public static function who() {
        echo CLASS."\n";
    }
}
C::test();

The result obtained here is A C C. Obviously, when calling parent::foo(), the runtime calling class is still used.

Another thing to note is: Only static classes that are explicitly declared are subordinate and subclasses.

The following part of the content refers to this blog post:Click to open the link:PHP static inheritance

<span style="font-size:18px;">class A { 
  protected static $var1 = null; 
  protected static $var2 = null; 
  public static function test(){ 
     if(!static::$var2){ 
          static::$var2 = static::$var1; 
     } 
     echo get_called_class().&#39; &#39;.static::$var2.&#39;
&#39;; 
  } 
} 
class B extends A { 
  protected static $var1 = &#39;b&#39;;   
} 
class C extends A { 
  protected static $var1 = &#39;c&#39;;   
} 
B::test(); 
C::test(); </span>

The result obtained here is b b. Here, class B first called the test() method, and the $var2 variable has been assigned a value after the call. However, class C has not defined its own $var2 variable, and the $var2 variable value already exists in the parent class, so it can be used directly. If in class B If $var2 variable is explicitly defined in , the result will be different.

The above is the detailed content of Detailed explanation of the usage and precautions of the static keyword in PHP. For more information, please follow other related articles on the PHP Chinese website!