Summary of usage of php variable scope

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.

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 to say, they can be used inside and outside functions, but this is only limited to PHP scripts included in one page (including the PHP scripts we include through include and include_once), but not in other pages. Can no longer be used.

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 as to avoid the previous problem. The variable inside the function has the same name as the external global variable and overrides the external 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 situation 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:

$a = 4;
function sendValue($x)
{
echo $x;
}
sendValue($a);
?>

Explanation: $a is defined outside the function, and the function defines parameters. When the function is called, $a will be passed in the form of parameters. So the above code can run normally.

$a = 4;
function sendValue()
{
echo $a;
}
sendValue();
?>

: 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, its effective scope). Most PHP variables have only a single scope. This single scope span also includes files introduced by include and require. example:

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

The variable $a here will take effect in the include 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:

$a = 1; /* global scope */
function Test()
{
 echo $a; /* reference to local scope variable */
}
Test();
?>

There will be no output from this script because the echo statement refers to a local version of the variable $a, and it is not assigned a value in this scope. 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

$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 instead of global

$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

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 'global' ' statement. Superglobals were introduced in PHP 4.1.0.
 print $_POST['name'];
}
?>

Use static variables Another important feature of variable scope is static variables. 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. Demonstrates the need for static variables

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

This function has nothing Useful because each call will set the value of $a to 0 and 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 does not lose the current count value, define the variable $a as static:

Example 12-5. Example of using static variables

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. 1 2 Next Page Last Page