PHP quoting is a bad habit_PHP Tutorial-PHP Tutorial-php.cn

PHP quoting is a bad habit_PHP Tutorial

WBOY

Release： 2016-07-21 15:39:37

Original

1344 people have browsed it

Copy code The code is as follows:

 
function binsearch(&$arr, $key, $value) 
{ 
$ low = 0; 
$high = count($arr); 
while ($low <= $high) { 
$mid = floor($low + ($high - $low) / 2 ); 
$item = $arr[$mid][$key]; 
if ($item == $value) { 
return $mid; 
} else if ($value > $item) { 
$low = $mid + 1; 
} else { 
$high = $mid - 1; 
} 
} 
return false; 
} 

Here, $mid is calculated by subtracting first and adding later, in order to prevent integer overflow. I didn’t mean to make it complicated.
I used the following code for testing:

Copy code The code is as follows:

 
$data = array(); 
for ($i = 0; $i < 1000000; $i++) 
{ 
$data[] = array("sq" => $i * 2); 
} 
var_dump(binsearch($data, "sq", 10000)); 

I found that binsearch always takes about 0.2s. Theoretically speaking, 1 million data can be cycled 20 times at most. How could it be so slow?
Later I monitored the memory and found that the data array occupied 230M of memory. When binsearching, it occupied 60K of memory. However, in theory, binsearch
shouldn't take up so much memory. Because, I think, I have used references and have not modified the data structure at all.
I was also puzzled. Later, I removed the reference parameter, and binsearch only took 0.0002s. It seemed that the reference consumed a lot of CPU resources.
PHP internally follows a copy on write principle. Actually this reference is redundant.
But why does it slow down when adding references? Today we will focus on this issue. After understanding the truth, everyone must know how to use quotations.
If you directly $a = &$data before calling binsearch, the speed of this reference will be very fast. It seems that the problem is definitely not caused by the reference itself.
This question actually involves how the zend engine manages PHP variables.
Look at the following question first:

Copy the code The code is as follows:

 
function demo (&$a, &$b) { $a =& $b; } 
$a = 1; 
$b = 2; 
demo($a, $b); 
$ b = 3; 
print $a; 
?> 

$a What is the output? Yes, it’s 2. However, I thought it was 3 at first.
So how to explain the above problem?
In fact, the parameter reference of the function is done like this.

Copy code The code is as follows:

 
$tmp = $a; 
$a1 = &$tmp; 
$a = $tmp; 
unset($a1, $tmp); 

Here, the reference is actually a temporary variable. At this time, $tmp has a reference attribute, but the $a variable does not.
According to the memory management method of zend engine, internally, it cannot be represented by a zval, and this zval must be forcibly separated.
Using this understanding method, the above problem is solved. Inside the function, the reference characteristics outside the function will not be changed. This is why PHP
does not support the use of calltime_by_ref, and chooses the inefficient copy method above.
The following analysis can also prove that copying does occur when passing parameters.
Inside the binsearch function.
$data[0] = 1;
In this way, a copy of the zval where $data is located will occur. Memory usage is 60K. It is exactly the same as function call and reference.
Many people may wonder why it is not 230M more. This is actually the brilliance of PHP. The array Key corresponds to a zval pointer. (Internal is a hash table)
So, just copy these pointers once, and the data does not need to be copied. However, a PHP hash table of 1 million actually takes up 50M of memory. Why is it only 60K?
Outside the binsearch function, run

Copy the code The code is as follows:

 
$t = $data; 
$t[0] = 1; 
unset($t); 

Sure enough, 60K more memory. It is probably related to PHP's memory management mechanism.
Now everything is clear! Today, I thought about it for several hours before I figured it out, and I didn’t dare to keep it to myself.
The reference in the function is not for you to pass parameters conveniently, but for you to realize that a function can have multiple return values, so it is best not to add any unnecessary details.
In fact, using a reference to it will reduce performance.