Three implementation methods of php recursive function and how to implement digital accumulation, php recursion_PHP tutorial

Three implementation methods of php recursive function and how to implement digital accumulation, php recursive

Recursive function is a commonly used type of function in programming. Its characteristic is that the function itself can Call itself, but you must make a conditional judgment before calling itself, otherwise it will cause infinite calls. This article lists three recursive function implementation methods. The first uses references as parameters, the second uses global variables, and the third uses static variables. Understanding such problems requires some basic knowledge, including global variables, references, and static variables. understanding, and also need to have an understanding of their scope of action. No more nonsense here, please see below for detailed introduction.

The first method: use references as parameters

Regardless of whether the reference is a parameter or not, we must first understand what a reference is? A reference simply means that two variables with different names point to the same storage address. Originally, each variable had its own storage address, and assignment and deletion went their own way.

Okay now, the two variables share a storage address. $a=&$b; . What it actually means is that $a has to share a room with $b regardless of its original storage address. Therefore any change to the stored address value will affect both values. ​

Functions have their own way of doing things, even if they have the same name. Recursive functions consider taking references as parameters and becoming a bridge to form data sharing between two functions. Although the two functions seem to operate on different addresses, they actually operate on the same memory address.

Copy code The code is as follows:
function test($a=0,&$result=array()){
$a ;
if ($a<10) {
$result[]=$a;
Test($a,$result);
}
echo $a;
return $result;
}

The above example is very simple. Use a<10 as the judgment condition. If the condition is true, assign a to result[]; passing the reference of result into the function will generate each recursion The a is added to the result array result. Therefore, the $result array generated in this example is Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4 ] => 5 [5] => 6 [6] => 7 [7] => 8 [8] => 9 ).

What is more interesting in this example is the value of echo a . I believe many people think it is 12345678910, but actually it is not, it is 1098765432. Why? Because the function has performed the next function recursion before executing echo a.

Really execute Echo A When A & LT; 10 The conditions are not satisfied, Echo A , return Result, For the above For one layer, after executing the recursive function, start executing the echo $a of this layer, and so on.

Second method: Use global variables

Use global variables to complete recursive functions. Please make sure you understand what global variables are

. globalDeclaring variables within a function is nothing more than a reference to an external variable with the same name. The scope of the variable is still within the scope of this function. Changing the values ​​of these variables will naturally change the values ​​of external variables with the same name. But once & is used, the variable with the same name is no longer a reference with the same name. It is not necessary to understand such a deep level to use global variables to implement recursive functions. You can understand recursive functions naturally by maintaining the original view of global variables.

Copy code The code is as follows: function test($a=0,$result=array()){
global $result;
$a ;
If ($a<10) {
          $result[]=$a;
         test($a,$result);
}
Return $result;
}

The third method: using static variables

We often see

static in classes, today we use it in recursive functions. Remember the role of static: initialize the variable only the first time the function is called, and retain the variable value.

　

For example:

Copy code The code is as follows: function test(){
static $count=0;
echo $count;
$count ;
}
test();
test();
test();
test();
test();
​

What is the execution result of this code? Is it

00000? Definitely not. It’s 01234. First, call test(), static for the first time to initialize $count . After each execution, the value of $count will be retained and will not be repeated. Initialization is equivalent to directly ignoring the sentence static $count=0;.

Therefore, the effect of applying static to a recursive function can be imagined. Use static to initialize variables that need to be used as "bridges" between recursive functions. Each recursion will retain the value of the "bridge variable".

Copy code The code is as follows:
function test($a=0){
​ static $result=array();
$a ;
If ($a<10) {
          $result[]=$a;
         test($a);
}
Return $result;
}

Summary

The so-called recursive function focuses on how to handle the function call itself and how to ensure that the required results can be reasonably "transmitted" between functions. Of course, there are also recursive functions that do not require the transfer of values ​​between functions, such as:

Copy code The code is as follows:
function test($a=0){
$a ;
If ($a<10) {
echo $a;

         test($a);
}
}

Let’s use a piece of code to demonstrate how PHP uses recursive functions to accumulate numbers.

The code is as follows:

Copy code The code is as follows:
function summation ($count) {
if ($count != 0) :
Return $count summation($count-1);
Endif;
}
$sum = summation(10);
print "Summation = $sum";
?>

When facing PHP recursive functions, there is no need to worry. An in-depth understanding of variable reference related knowledge is very helpful to solve such problems. The above content is the three implementation methods of PHP recursive functions and how to realize the accumulation of numbers. I hope it will be helpful to everyone in your future study.

http://www.bkjia.com/PHPjc/1044861.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/1044861.htmlTechArticleThree implementation methods of php recursive functions and how to implement digital accumulation. PHP recursive functions are commonly used in programming A type of function whose characteristic is that the function itself can call itself, but it must...