Detailed explanation of static variables in PHP

Static variable The type specifier is static. Static variables belong to the static storage method, and their storage space is the static data area in the memory (storage units are allocated in the static storage area). The data in this area always occupies these storage spaces during the entire running period of the program (during the entire running period of the program are not released), it can also be considered that its memory address remains unchanged until the entire program ends (on the contrary, while auto automatic variables, that is, dynamic local variables, belong to the dynamic storage category, occupy dynamic storage space, and are released after the function call is completed). Although static variables always exist throughout the execution of the program, they cannot be used outside its scope.

In addition, variables belonging to the static storage method are not necessarily static variables. For example: Although external variables (referred to as global variables in PHP) are static storage methods, they are not necessarily static variables. They must be defined by static before they can become static external variables, or static global variables.

All global variables are static variables, and local variables are local static variables only when they are defined with the type modifier static.

Static variables can be applied anywhere. Once the application is successful, it will no longer accept other similar applications.

Static variables do not mean that they cannot change the value. A quantity that cannot change the value is called a constant. The value it holds is mutable, and it will remain up-to-date. It is said to be static because it does not change as the function is called and exits. That is, if we assign a certain value to a static variable the last time the function is called, the value will remain unchanged the next time the function is called.

1. Static local variables:

1. Internal variables of static type are the same as auto automatic variables (that is, local variables without static declaration). They are local variables of a specific function. That is, the variable can only be used within the function in which it is defined. The scope of the two is the same; the difference between the two is that the auto automatic variable will exist and disappear as the function is called and exits, while the static class local variable will not. It will exist regardless of whether the function in which it is located is called; however, although the variable continues to exist, it cannot be used. If the function that defines it is called again, it can continue to be used, and the value left after the previous call is saved. In other words, an internal variable of static type is a variable that can only be used in a specific function, but always occupies storage space.

2. If a static variable is initialized while defining a static variable in the function body, the program will no longer perform initialization operations in the future (the static variable initialization statement of the basic type that appears inside the function will only be initialized on the first call). implement). Assigning initial values ​​to automatic variables is performed when the function is called. Each time the function is called, the initial value is assigned again, which is equivalent to executing an assignment statement.

3. The initialization expression of static local variables must be a constant or constant expression. Even if a local static variable is defined without an initial value, the system will automatically assign an initial value of 0 (for numeric variables) or a null character (for character variables); the initial value of a static variable is 0. For the automatic variable auto, if no initial value is assigned, its value will be an uncertain value.

4. When a function is called multiple times and the values ​​of certain variables are required to be retained between calls, static local variables can be considered. Although global variables can also be used to achieve the above purpose, global variables sometimes cause unexpected side effects (mainly caused by the scope of the variable), so it is still better to use local static variables.

Note: Local static variables take up a long time in memory and have poor readability. Therefore, try to avoid using local static variables unless necessary.

2. Static global variables

The declaration of a global variable (external variable) is preceded by static to constitute a static global variable.

Global variables themselves are static storage methods, and static global variables are of course also static storage methods.

There is no difference between the two in storage methods.

The difference between the two is:

1. The scope of non-static global variables is the entire source program. When a source program consists of multiple source files, the scope of non-static global variables Variables are valid across source files.

2. Static global variables limit their scope, that is, they are only valid within the source file in which the variable is defined, and cannot be used in other source files of the same source program.

It can be seen from the above analysis————

Changing a local variable to a static variable changes its storage method, that is, changes its lifetime.
Changing a global variable to a static variable changes its scope and limits its scope of use. static static variables will be placed in the global storage area of ​​​​the program (that is, in the global data area of ​​​​the program, rather than allocated on the stack, so it will not cause stack overflow), so that the original assignment can be maintained the next time it is called. . This is what differentiates it from stack variables and heap variables.

3. Application in PHP

<?php
//--------------如何理解static静态变量-----------
 
/** 普通局部变量 */
function local() {
    $loc = 0; //这样，如果直接不给初值0是错误的。
    ++$loc;
    echo $loc . &#39;<br>&#39;;
}
local(); //1
local(); //1
local(); //1
echo &#39;===================================<br/>&#39;;
 
/** static静态局部变量 */
function static_local() {
    static $local = 0 ; //此处可以不赋0值
    $local++;
    echo $local . &#39;<br>&#39;;
}
static_local(); //1
static_local(); //2
static_local(); //3
//echo $local; 注意虽然静态变量，但是它仍然是局部的，在外不能直接访问的。
echo &#39;=======================================<br>&#39;;
 
/** static静态全局变量(实际上:全局变量本身就是静态存储方式,所有的全局变量都是静态变量) */
function static_global() {
    global $glo; //此处，可以不赋值0，当然赋值0，后每次调用时其值都为0，每次调用函数得到的值都会是1，但是不能想当然的写上"static"加以修饰，那样是错误的.
    $glo++;
    echo $glo . &#39;<br>&#39;;
}
static_global(); //1
static_global(); //2
static_global(); //3
?>

Related recommendations:

php: Analysis of the difference between static static variables and ordinary variables

Detailed explanation of the difference between static static local variables and static global variables

static static variables of PHP

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