A brief analysis of some issues with PHP variable scope

A brief analysis of some issues with PHP variable scope_PHP Tutorial

WBOY

Release： 2016-07-21 14:59:46

Original

742 people have browsed it

I encountered such a problem last night, it was a problem with global variables in functions. I did a search today and found a pretty good article about variable scope in PHP. It was translated by a netizen and posted here:

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 the 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:

$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 has not been 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 code The code is as follows:

$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:

$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:

function test_global()
{
// Most predefined variables are not "super", they need to use the 'global' keyword to make them in the function Valid in the local zone.
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 a 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 example below:

Example 12-4. Demonstrate an example that requires static variables

Copy the code The code is as follows:

function Test ()
{
 $a = 0;
 echo $a;
 $a++;
}
?> 

This function is not very useful because it will set the value of $a to 0 and output "0" every time it is called. $a++, which increments the variable by one, has no effect because the variable $a no longer exists once the function exits. To write a counting function that does 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:

function Test()
{
 static $a = 0;
 echo $a;
 $a++;
}
?> 

Now, every time the Test() function is called, the value of $a will be 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 code The code is as follows:

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:

< ;?php
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;
}
?>

Global and static variable references
in Zend engine The 1st generation drives PHP4, and 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:

< ;?php
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);
?>

Execute the above example Will result in the following output:
NULLobject(stdClass)(0) {}
Similar behavior also applies to static statements. References are not stored statically:

Copy code The code is as follows:

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:
Static object: NULLStatic object: NULLStatic object: NULLStatic object: object(stdClass)(1) { ["property"]=> ; int(1)}

The 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.