In-depth analysis of the problem of using php unset global variables

In-depth analysis of the problem of using php unset global variables_PHP tutorial

WBOY

Release： 2016-07-21 15:05:48

Original

797 people have browsed it

PHP unset global variables can only destroy local variables in actual use and cannot achieve the purpose of global variables. Let's solve this problem in detail below. Hope it helps everyone.

Some functions in the PHP language are difficult to understand literally for beginners. It is necessary to sum up experience in actual coding to master this knowledge. What we want to introduce to you today are some problems encountered in the use of PHP unset global variables.

There is a statement to release variables in PHP called unset (starting from PHP4, unset is no longer a function, but a statement). Something went wrong when using unset a few days ago, so I changed unset The problem is summarized below. If you have read the PHP manual carefully, then there is no need to read this article. This article is for students who do not pay attention to the manual.

The first thing to emphasize is that the PHP unset global variable is no longer a function in PHP. Since it is not a function, there is no return value, so you cannot use the return value of unset when using it. Make judgments.

Secondly, in a function, PHP unset global variables can only destroy local variables, but not global variables. Let’s take a look at an example in the manual

Copy code The code is as follows:

 < ?PHP
 function destroy_foo() {
 global $foo;
 unset($foo);
 }
 $foo = 'bar';
 destroy_foo();
 echo $foo;
 ?> 

The returned result is
bar
Why What will happen? The reason is that PHP unset global variables can only destroy local variables in functions. What should you do if you need to destroy global variables in your program? It's also very simple, implemented using the $GLOBALS array. Look at the example below:

Copy code The code is as follows:

 < ?PHP
 function foo() {
 unset($GLOBALS['bar']);
 }
 $bar = “something”;
 foo();
 var_dump($bar);
 ?> 

The PHP unset() function is used by us to destroy variables, but it often cannot release the data in the memory during actual operation. In the article, we will explain the solutions to the relevant problems in detail.

When we learn the PHP language, the usage of each function is usually vague, and it is difficult to master them one by one. But we must master these functions. Below we will introduce in detail how to use the PHP unset() function.

PHP unset() function is used to destroy variables, but many times, this function only destroys the variable, and the value of the variable stored in the memory is still not destroyed, which means it does not achieve what we want. The desired effect of releasing memory. Here I suggest you use the $variable=null method to release its memory. You will know the reason after reading the following.

The following are some key points about the PHP unset() function: (The following are all tested in the windows environment, php 2.5.9)
This function The memory will be released only when the space occupied by the variable value exceeds 256 bytes long
The address will be released only when all variables pointing to the value (such as reference variables pointing to the value) are destroyed (also To perform the judgment of 1)
The following is an example code argument:

Copy the code The code is as follows:

 < ?php
 $test=str_repeat("1",256); //Repeat a string, and the return value is the repeated string 
 $s = memory_get_usage(); 
 //This function Used to view the currently used memory 
 unset($test);
 $e = memory_get_usage();
 echo ' Release memory: '.($s-$e); 
 //The output is 272, but if the test variable above is changed to $test=str_repeat("1",255), the output will be 0. If the variable value is less than 256, the memory will not be released 
?> 

As for why it is 272 instead of 256, it is not very clear. I don’t know how it is handled internally.

Copy code The code is as follows:

 < ?php
 $test = str_repeat("1",256) ;
 $p = &$test;
 unset($test);
 echo $p; 
 //The output is 256 ones. If the above is changed to unset($p), it will not work anymore. The echo $test will directly display 256 1
 ?> 

. That is to say, the value assigned to $a in the memory is still exist. It can be seen that unset() does not achieve the effect of releasing memory.
But if you add $test=null to the above code, or add an unset($p), you can achieve the effect of releasing memory. The PHP unset() function test code is as follows:
Variable assignment For null method:

Copy the code The code is as follows:

 < ?php
 $test = str_repeat("1",256);
 $p = &$test;
 $s = memory_get_usage(); 
 $test = null;
 unset($test); //Try switching the order of this sentence with $test=null, the result will be different
 $e = memory_get_usage();
 echo ' Release memory : '.($s-$e);
 //The output is 272
 var_dump($p); //The output is NULL
 ?> 

will point to Method to destroy all variables with values in this address:

Copy code The code is as follows:

 < ?php
 $test = str_repeat("1",256);
 $p = &$test;
 $s = memory_get_usage(); 
 //Note that it does not matter if the order of the following two unset() is reversed. Does not affect the result
 unset($p);
 unset($test); 
 $e = memory_get_usage();
 echo ' Release memory: '.($s-$e); / /The output is 272
?> 

The PHP unset() function demonstration is completed.