In-depth analysis of PHP variable scope_PHP tutorial-PHP Tutorial-php.cn

Every variable in PHP has a scope specific to it, which is the area within which the variable (and thus its value) can be accessed. For starters, the scope of variables is the page they reside on. Therefore, if you define $var, the rest of the page can access $var, but other pages generally cannot access it (unless special variables are used).

Because included files work as if they were part of the original (included) script, variables defined before the include() line are available to the included file. Additionally, variables defined within the include file are available to the parent (include) script after the include() line.

All of this will become less obvious when using your own defined functions. These functions have their own scope, which means that variables used within a function cannot be used outside it, and variables defined outside a function cannot be used inside it. For this reason, variables inside a function can have the same name as variables outside it, but they are still completely different variables with different values. This is a confusing concept for most novice programmers.
To change the scope of variables within a function, you can use the global statement.

Copy code The code is as follows:

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com /-->function function_name() {
 global $var;
}
$var=20;
function_name(); // Function call.
?>

In this example, $var inside the function is now the same as $var outside the function. This means that the variable $var already has a value of 20, and if this value is changed inside the function, the value of $var outside will also change.
Another way to avoid variable scope is to use superglobal variables: $_GET, $_POST, $_REQUEST, etc. These variables are automatically accessible within your function (thus, they are superglobal variables). You can also add elements to the $GLOBALS array so that they can be used within functions.

In other words, it is best not to use global variables within functions. When designing functions, you should make them accept every value as a parameter as needed and return any value as needed. Relying on global variables within functions would make them more context-dependent and therefore less useful.
Variables in PHP mainly include: built-in super global variables, general variables, constants, global variables, static variables, etc.

Built-in super global variables can be used and visible anywhere in the script. That is, if we change one of the values in a PHP page, its value will also change when used in other PHP pages.

• Once declared, constants will be globally visible, that is, they can be used inside and outside functions, but this is only limited to PHP scripts included in a page (including PHP scripts we include through include and include_once), but It cannot be used in other pages.
•Global variables declared in a script are visible throughout the script, but not inside the function. If the variable inside the function has the same name as the global variable, the variable inside the function shall prevail.
•When the variables used inside the function are declared as global variables, their names must be consistent with the names of the global variables. In this case, we can use the global variables outside the function in the function, so that we can avoid A situation where the external variable is overwritten because the variable inside the function has the same name as the external global variable.
•Variables created and declared as static inside a function cannot be visible outside the function, but the value can be maintained during multiple executions of the function. The most common case is during the recursive execution of the function.
•Variables created inside a function are local to the function and cease to exist when the function terminates.
The complete list of super global variables is as follows:
•.$GOBALS Array of all global variables
•.$_SERVER Array of server environment variables
•. $_POST Variable array passed to the script through the POST method
•.$_GET Variable array passed to the script through the GET method
•.$_COOKIE cookie variable array
•.$_FILES Related to file upload Variable array
•.$_ENV Environment variable array
•.$_REQUEST Variable array entered by all users including input content contained in $_GET $_POST $_COOKIE
•.$_SESSION Session variable array
Explanation with examples:

Copy code The code is as follows:

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--> $a = 4;
 function sendValue($x) 
 {
 echo $x;
 }
 sendValue($a);
?>

Explanation: $a is defined outside the function, and the function is defined When the function is called, $a will be passed as a parameter. So the above code can run normally.

Copy code The code is as follows:

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com /--> $a = 4;
 function sendValue()
 {
 echo $a;
 }
 sendValue();
? >

Explanation: When the function is called, $a cannot be passed as a parameter. So the above code cannot run normally.
Variable Scope
The scope of a variable is the context in which it is defined (Translator: To put it bluntly, it is its effective scope). Most PHP variables have only a single scope. This single scope span also includes files introduced by include and require. Example:

Copy code The code is as follows:

 $a = 1;
 include "b.inc";
?> 

Here variable $a will take effect in the included file b.inc. However, in user-defined functions, a local function scope will be introduced. Any variables used inside a function will be restricted to the local function scope by default. Example:

Copy code The code is as follows:

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter .com/-->$a = 1; /* global scope */
function Test()
{
 echo $a; /* reference to local scope variable */
}
Test();
?>

This script will not produce any output because the echo statement refers to a local version of the variable $a, and Within this scope, it is not assigned a value. You may notice that PHP's global variables are a little different from C language. In C language, global variables automatically take effect in functions unless overridden by local variables. This can cause problems, as someone might carelessly change a global variable. Global variables in PHP must be declared global when used in functions.
The global keyword
First, an example of using global:
Example 12-1. Using global

Copy the code The code is as follows:

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->$a = 1;
$b = 2;
function Sum()
{
 global $a, $b;
 $b = $a + $b;
}
Sum();
echo $b;
?>

The output of the above script will be "3". Global variables $a and $b are declared in the function, and all reference variables of any variable will point to the global variables. PHP has no limit on the maximum number of global variables that a function can declare.
The second way to access variables in the global scope is to use a special PHP custom $GLOBALS array. The previous example can be written as:
Example 12-2. Use $GLOBALS to replace global

Copy the code The code is as follows:

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->$a = 1;
$b = 2;
function Sum( )
{
 $GLOBALS["b"] = $GLOBALS["a"] + $GLOBALS["b"];
}
Sum();
echo $b; 
?>

In the $GLOBALS array, each variable is an element, the key name corresponds to the variable name, and the value variable content. $GLOBALS exists in the global scope because $GLOBALS is a superglobal variable. The following example shows the use of superglobal variables:
Example 12-3. Example demonstrating superglobal variables and scope

Copy the code The code is as follows:

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->function test_global()
{
 // Large Most predefined variables are not "super", they require the 'global' keyword to make them available in the local scope of the function. 
 global $HTTP_POST_VARS;
 print $HTTP_POST_VARS['name'];
 // Superglobals are valid in any scope, they do not require a 'global' declaration. Superglobals were introduced in PHP 4.1.0. 
 print $_POST['name'];
}
?>

Using static variables
Another important feature of variable scope is static variable ). Static variables only exist in the local function scope, but their values are not lost when program execution leaves this scope. Take a look at the following example:
Example 12-4. Demonstrate an example that requires static variables

Copy the code The code is as follows:

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->function Test ()
{
 $a = 0;
 echo $a;
 $a++;
}
?>

This function is useless because the value of $a will be set to 0 every time it is called. Output "0". $a++, which increments a variable by one, has no effect because the variable $a no longer exists once this function exits. To write a counting function that will not lose the current count value, define the variable $a as static:
Example 12-5. Example of using static variables

Copy Code The code is as follows:

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->function Test()
{
 static $a = 0;
 echo $a;
 $a++;
}
?>

Now, Each time the Test() function is called, the value of $a is output and incremented by one.
Static variables also provide a way to deal with recursive functions. A recursive function is a function that calls itself. Be careful when writing recursive functions, as they may recurse indefinitely. You must ensure that there are adequate ways to terminate recursion. Consider this simple function that recursively counts to 10, using the static variable $count to determine when to stop:
Example 12-6. Static variables and recursive functions

Copy codeThe code is as follows:

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->function Test() 
{
 static $count = 0;
 $count++;
 echo $count;
 if ($count < 10) {
 Test ();
 }
 $count--;
}
?>

Note: Static variables can be declared as shown in the above example. Assigning it with the result of an expression in a declaration will result in a parsing error.
Example 12-7. Declare static variables

Copy code The code is as follows:

Code highlighting produced by Actipro CodeHighlighter ( freeware)http://www.CodeHighlighter.com/-->function foo(){
 static $int = 0; // correct
 static $int = 1+2 ; // wrong (as it is an expression)
 static $int = sqrt(121); // wrong (as it is an expression too)
 $int++;
 echo $int;
 }
?>

References of global and static variables
In the Zend engine 1 generation, which drives PHP4, static and global definitions of variables are implemented in the form of references. For example, a true global variable imported with the global statement inside a function scope actually establishes a reference to the global variable. This may lead to unexpected behavior, as demonstrated in the following example:

Copy the code The code is as follows:

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->function test_global_ref() {
 global $obj;
 $obj = &new stdclass; 
}
function test_global_noref() {
 global $obj;
 $obj = new stdclass;
}
test_global_ref();
var_dump($obj);
test_global_noref();
var_dump($obj);
?>

Executing the above example will result in the following output:

Copy Code The code is as follows:

NULLobject(stdClass)(0) {}

Similar behavior also applies to static statements. References are not stored statically:

Copy code The code is as follows:

Code highlighting produced by Actipro CodeHighlighter (freeware)http ://www.CodeHighlighter.com/-->function &get_instance_ref() {
 static $obj;
 echo "Static object: ";
 var_dump($obj) ;
 if (!isset($obj)) {
 // Assign a reference to a static variable 
 $obj = &new stdclass;
 }
 $obj->property++;
 return $obj;
}
function &get_instance_noref() {
 static $obj;
 echo "Static object: ";
 var_dump($obj);
 if (! isset($obj)) {
 // Assign an object to a static variable 
 $obj = new stdclass;
 }
 $obj->property++;
 return $obj;
}
$obj1 = get_instance_ref();
$still_obj1 = get_instance_ref();
echo "n";
$obj2 = get_instance_noref();
$still_obj2 = get_instance_noref() ;
?>

Executing the above example will result in the following output:

Copy the code The code is as follows:

Static object: NULLStatic object: NULLStatic object: NULLStatic object: object(stdClass)(1) { ["property"]=> int(1)} 

Above example Demonstrates that when a reference is assigned to a static variable, its value is not remembered the second time the &get_instance_ref() function is called.