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

Local variables can be divided into dynamic storage types and static storage types in terms of storage methods. Local variables in a function, unless specifically declared as static storage class, will allocate storage space dynamically by default. The internal dynamic variables are automatically released after the function call. If you want the internal variables to remain in memory after the function is executed, you should use static variables. After the function is executed, the static variables will not disappear, but will be shared among all calls to the function. That is, when the function is executed again, the static variables will continue to operate from the previous results, and will only be used during the execution of the script. The period function is initialized the first time it is called. To declare a function variable as static, use the keyword static.

Earlier we introduced the local variables of the scope of php variables and the global variables of the scope of php variables. 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 when the function is called or 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 certain The local variable of a specific function, that is, the variable can only be used within the function in which the variable 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 variable will exist and disappear as the function is called and exits. Class local variables will not, they will always exist regardless of whether the function in which they are 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 form 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 static static local variables and static global variables

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, non-static global variables are valid in each source file.

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 the difference between it and Stack variables and Heap variables.

The sample code is as follows:

<?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
?>

The above is the detailed explanation of static static local variables and static global variables.

【Recommended related tutorials】

1. "php.cn Dugu Jiujian (4)-php video tutorial"

2. php programming from entry to mastering a full set of video tutorials

3. php practical video tutorial

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