Three ways to implement PHP recursive functions

　 Recursive functions are a type of function we commonly use. The most basic feature is that the function calls itself, but it must be conditionally judged before calling itself, otherwise it will continue to be called indefinitely. What methods can be used to implement recursive functions? This article lists three basic ways. Understanding it requires a certain amount of basic knowledge, including an understanding of global variables, references, static variables, and an understanding of their scope. Recursive functions are also a good technique for solving infinite levels of classification. If you are interested in infinite classification, please refer to PHP to use recursive functions to achieve infinite classification. I'm used to explaining complex truths in layman's terms. If you really don't understand, please refer to the manual.

Using references as parameters

Regardless of whether references are parameters 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 originally do their own thing, even if they are functions with 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.

<span>function</span> test(<span>$a</span>=0,&<span>$result</span>=<span>array</span><span>()){
</span><span>$a</span>++<span>;
</span><span>if</span> (<span>$a</span><10<span>) {
    </span><span>$result</span>[]=<span>$a</span><span>;
    test(</span><span>$a</span>,<span>$result</span><span>);
}<br />echo $a;
</span><span>return</span><span>$result</span><span>;

}</span>

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 Add $a to the results 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 ).

The more interesting thing about 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. The actual execution of echo $a is when the condition $a<10 is not met, echo $a returns $result. For the upper layer, after executing the recursive function, the echo $a of this layer starts to be executed, and so on.

Use global variables

Use global variables to complete recursive functions. Please make sure you understand what global variables are. The global variable declared within the function is just a reference to the 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.

<span>function</span> test(<span>$a</span>=0,<span>$result</span>=<span>array</span><span>()){
    </span><span>global</span><span>$result</span><span>;
    </span><span>$a</span>++<span>;
    </span><span>if</span> (<span>$a</span><10<span>) {
        </span><span>$result</span>[]=<span>$a</span><span>;
        test(</span><span>$a,$result</span><span>);
    }
    </span><span>return</span><span>$result</span><span>;
}</span>

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.

Give me an example:

<span>function</span><span> test(){
</span><span>static</span><span>$count</span>=0<span>;
</span><span>echo</span><span>$count</span><span>;

</span><span>$count</span>++<span>;
}
test();
test();
test();
test();
test();</span>

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 no longer be initialized, which is equivalent to directly ignoring static $count=0; This sentence.

　So the effect of applying static to a recursive function can be imagined. Variables that need to be used as "bridges" between recursive functions are initialized using static, and the value of the "bridge variables" will be retained for each recursion.

<span>function</span> test(<span>$a</span>=0<span>){
    </span><span>static</span><span>$result</span>=<span>array</span><span>();
    </span><span>$a</span>++<span>;
    </span><span>if</span> (<span>$a</span><10<span>) {
        </span><span>$result</span>[]=<span>$a</span><span>;
        test(</span><span>$a</span><span>);
    }
    </span><span>return</span><span>$result</span><span>;
}</span>

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 "transferred" between functions. Of course, there are also recursive functions that do not require the transfer of values ​​between functions, such as :

<span>function</span> test(<span>$a</span>=0<span>){
    </span><span>$a</span>++<span>;
    </span><span>if</span> (<span>$a</span><10<span>) {
        </span><span>echo</span><span>$a</span><span>;

        test(</span><span>$a</span><span>);
    }
}</span>

Facing such a function, we don’t have to worry about it. By the way, a deep understanding of variable references can go a long way in solving this type of problem.

The above introduces the three implementation methods of PHP recursive functions, including the relevant content. I hope it will be helpful to friends who are interested in PHP tutorials.