PHP recursive function Three implementation methods and how to achieve digital accumulation, PHP recursive _php tutorial

PHP recursive function Three implementation methods and how to achieve digital accumulation, PHP recursion

Recursive function is a kind of common function in programming, its feature is that function itself can call itself, but it must have conditional judgment before invoking itself, otherwise it will cause infinite call down. This article lists three recursive function implementation methods, the first use of reference to do parameters, the second use of global variables, the third use of static variables, to understand this kind of problem needs a bit of foundation, including the global variables, references, static variables of understanding, but also need to understand their scope of action. In this no nonsense, specific introduction please see below.

The first approach: using references to make parameters

First of all, regardless of the reference do not do parameters, you must first understand what is the reference? A reference simply refers to a variable of two different names pointing to the same storage address. Each variable has its own storage address, and the assignment deletes the lines.

Now, two variables share a single storage address. $a =& $b; 。 In fact, $a regardless of their original storage address, do not want to share a room with the $b . Therefore, any change to the value of the stored address will affect both values.

Functions are inherently fragmentation, even for functions with the same name. The recursive function is to consider the reference as a parameter, to become a bridge, to form a data share between two functions. Although the two functions seem to operate on a different address, the actual operation is a memory address.

Copy the Code code 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 a very simple answer, with a<10 as a condition, the condition is set, then assigns a to result[]; passing the reference of result to a function adds each recursive result of a to the resulting array of results. Thus, the $result array generated by this example is arrays ([0] = 1 [1] = 2 [2] = 3 [3] = 4 [4] = 5 [5] = 6 [6] => 7 [7] = 8 [8] = 9).

The interesting thing about this example is the value of echo a . I believe many people think it is 12345678910 , but it is 1098765432. Why is it? The next recursive function is performed because the function has not executed echo a.

The true echo a is when the a<10 condition is not satisfied,echo a, returns result, for the previous level, executes the recursive function, starts to perform this layer's echo $a, and so on.

Second approach: Take advantage of global variables

Using global variables to complete the recursive function, make sure you do understand what global variables are . Global declares that a variable is simply 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, the value of the external variable with the same name has changed naturally. But once &is used, the variable with the same name is no longer referenced by the same name. Using global variables to implement recursive functions it is not necessary to understand such a deep layer, but also to maintain the original view of global variables can logically understand the recursive function.

Copy the Code code as follows:
function test ($a =0, $result =array ()) {
Global $result;
$a + +;
if ($a <10) {
$result []= $a;
Test ($a, $result);
}
return $result;
}

Third approach: using static variables

We often see staticin classes, and today we use it in recursive functions. Remember the function of static: Initializes the variable only the first time it is called, and retains the value of the variable.

　　Give me a chestnut:

Copy the Code code as follows:
function Test () {
static $count = 0;
Echo $count;
$count + +;
}
Test ();
Test ();
Test ();
Test ();
Test ();
　　

What is the execution result of this section of code? Is it 00000 ? Not necessarily. It's 01234. First Call test (), static $count initialization, after each execution will retain the value of $count , no longer initialized, the equivalent of directly ignored static $count =0; This sentence.

Thus it is conceivable to apply static to the function of recursion. Variables that need to be "bridges" between recursive functions are initialized with static , and each recursion retains the value of the bridge variable .

Copy the Code code as follows:
function test ($a =0) {
Static $result =array ();
$a + +;
if ($a <10) {
$result []= $a;
Test ($a);
}
return $result;
}

　

Summarize

The so-called recursive function, the focus is how to deal with the function call itself is how to ensure that the required results can be reasonably "passed" between functions, of course, there is no need to pass the function between functions worthy of recursive functions, for example:

Copy the Code code as follows:
function test ($a =0) {
$a + +;
if ($a <10) {
echo $a;

Test ($a);
}
}

Here's a piece of code that demonstrates how PHP uses recursive functions to accumulate numbers.

The code looks like this:

Copy the Code code as follows:
<?php
Function summation ($count) {
if ($count! = 0):
Return $count + summation ($count-1);
endif
}
$sum = summation (10);
print "summation = $sum";
?>

In the face of PHP recursive function, do not have to worry about, in-depth understanding of variable reference related knowledge to solve such problems is very helpful, the above content is the PHP recursive function three implementation methods and how to achieve the full content of the digital accumulation, I hope that everyone in the future to learn something helpful.

http://www.bkjia.com/PHPjc/1044861.html www.bkjia.com true http://www.bkjia.com/PHPjc/1044861.html techarticle PHP Recursive function Three implementation methods and how to achieve digital accumulation, PHP recursive recursive function in the programming is a relatively common class of functions, which is characterized by the function itself can call itself, but must ...

