


Three ways to implement PHP recursive functions, three ways to implement PHP recursive functions_PHP tutorial
Jul 13, 2016 am 09:45 AMThree ways to implement recursive functions in php, three kinds of recursive functions in php
Recursive functions are a type of function we commonly use, the most basic feature is the function Self calls itself , but it must conditionally judge 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 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.
<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[]; pass the reference of $result into the function, and the $ generated by each recursion will be a is added 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 ) .
What is more interesting in this example is the value of echo $a. I believe many people think it is 12345678910, but 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.
Using 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>
Use static variables
We often see static in classes, and today we use it in recursive functions. Please remember the role of static: variables are initialized only when calls the function for the first time, and retains the variable value.
For 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() for the first time, static initializes $count, and will retain $count after each execution. The value is no longer initialized, which is equivalent to directly ignoring the sentence static $count=0;.
Therefore, 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 "transmitted" 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>
Faced with 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.

Hot AI Tools

Undress AI Tool
Undress images for free

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

Notepad++7.3.1
Easy-to-use and free code editor

SublimeText3 Chinese version
Chinese version, very easy to use

Zend Studio 13.0.1
Powerful PHP integrated development environment

Dreamweaver CS6
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

Hot Topics

To optimize the performance of recursive functions, you can use the following techniques: Use tail recursion: Place recursive calls at the end of the function to avoid recursive overhead. Memoization: Store calculated results to avoid repeated calculations. Divide and conquer method: decompose the problem and solve the sub-problems recursively to improve efficiency.

Python is a very powerful programming language, and many programmers choose Python as their main programming language. However, too much function nesting in the code can make the program difficult to maintain and understand. This article will explore how to solve the excessive function nesting error in Python code. A brief introduction to function nesting Function nesting refers to the process of defining another function in the body of a function. Function nesting can make the structure of the program clearer and the code easier to read and maintain. However, too many nested functions can lead to an overly complex code structure.

The exit conditions of C++ recursive functions include: Baseline conditions: Check whether the function reaches a state that can directly return results, usually judging whether a certain condition or parameter value meets the threshold. Recursion termination condition: Alternative to or in addition to the baseline condition, ensuring that the function stops after a certain number of recursive calls, by tracking the recursion depth or setting a maximum recursion depth limit.

In Golang, recursion is a way for a function to call itself. Many problems can be solved using recursive functions, such as calculating factorials, Fibonacci sequences, etc. However, when writing recursive functions, you need to pay attention to some details, otherwise program errors may occur. This article will introduce the details of recursive functions in Golang to help developers write more stable and reliable recursive functions. Handling of basic situations When writing a recursive function, you first need to consider the basic situation, that is, the conditions for the exit of the recursive function. If there is no positive

Recursive functions are used in search algorithms to explore tree-like data structures. Depth-first search uses a stack to explore nodes, while breadth-first search uses a queue to traverse layer by layer. In practical applications, such as finding files, recursive functions can be used to search for a given file in a specified directory.

Here we have a directory. Our task is to create a C program to list all files and subdirectories in a directory. A directory is a place/area/location where a set of file(s) will be stored. A subdirectory is a directory within the root directory, which, in turn, can have another subdirectory. In C programming language you can easily list all files and subdirectories in a directory. The following program shows how to list all files and subdirectories in a directory. //C program example to list all files and subdirectories in the directory Live demonstration #include<stdio.h>#include<dirent.h>intmain(void){ &am

How to implement factorial using recursive functions in Go language? Factorial is a common calculation in mathematics that multiplies a non-negative integer n by all positive integers smaller than it, up to 1. For example, the factorial of 5 can be expressed as 5!, calculated as 54321=120. In computer programming, we often use recursive functions to implement factorial calculations. First, we need to understand the concept of recursive functions. A recursive function refers to the process of calling the function itself within the definition of the function. When solving a problem, a recursive function will continually

The tail recursion optimization strategy effectively reduces the function call stack depth and prevents stack overflow by converting tail recursive calls into loops. Optimization strategies include: Detect tail recursion: Check whether there are tail recursive calls in the function. Convert functions into loops: Use loops instead of tail-recursive calls and maintain a stack to save intermediate state.
