Drei Möglichkeiten, rekursive PHP-Funktionen zu implementieren

Rekursive Funktionen sind eine Art von Funktion, die wir häufig verwenden. Die grundlegendste Funktion besteht darin, dass die Funktion sich selbst aufruft. Sie muss jedoch vor dem Aufruf selbst bedingt beurteilt werden, da sie sonst auf unbestimmte Zeit aufgerufen wird. Mit welchen Methoden können rekursive Funktionen implementiert werden? In diesem Artikel werden drei grundlegende Möglichkeiten aufgeführt. Um es zu verstehen, ist ein gewisses Maß an Grundwissen erforderlich, einschließlich eines Verständnisses globaler Variablen, Referenzen, statischer Variablen und eines Verständnisses ihres Umfangs. Rekursive Funktionen sind auch eine gute Technik zur Lösung unendlicher Klassifizierungsebenen. Wenn Sie an einer unendlichen Klassifizierung interessiert sind, lesen Sie bitte PHP, um mithilfe rekursiver Funktionen eine unendliche Klassifizierung zu erreichen. Ich bin es gewohnt, komplexe Wahrheiten in Laienbegriffen zu erklären. Wenn Sie es wirklich nicht verstehen, schauen Sie bitte im Handbuch nach.

Referenzen als Parameter verwenden

Unabhängig davon, ob Referenzen Parameter sind oder nicht, müssen wir zunächst verstehen, was eine Referenz ist? Eine Referenz bedeutet einfach, dass zwei Variablen mit unterschiedlichen Namen auf dieselbe Speicheradresse verweisen. Ursprünglich hatte jede Variable ihre eigene Speicheradresse und das Zuweisen und Löschen verlief auf eigene Weise. Okay, jetzt teilen sich die beiden Variablen eine Speicheradresse. $a=&$b;. Was es tatsächlich bedeutet, ist, dass $a einen Raum mit $b teilen muss, unabhängig von seiner ursprünglichen Speicheradresse. Daher wirkt sich jede Änderung des gespeicherten Adresswerts auf beide Werte aus. ​

Funktionen erledigen ursprünglich ihre eigene Sache, auch wenn es sich um Funktionen mit demselben Namen handelt. Rekursive Funktionen berücksichtigen Referenzen als Parameter und werden zu einer Brücke, um den Datenaustausch zwischen zwei Funktionen zu bilden. Obwohl die beiden Funktionen scheinbar an unterschiedlichen Adressen arbeiten, arbeiten sie tatsächlich an derselben Speicheradresse.

<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>) {
    <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>

Das obige Beispiel ist sehr einfach. Verwenden Sie $aArray ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4 ] = > 5 [5] => 6 [6] => 8 [8] =>

Was in diesem Beispiel interessanter ist, ist der Wert von echo $a. Ich glaube, viele Leute denken, es sei 12345678910, aber in Wirklichkeit ist es nicht so, es ist 1098765432. Warum? Weil die Funktion die nächste Funktionsrekursion durchgeführt hat, bevor sie echo $a ausführt. Die tatsächliche Ausführung von echo $a erfolgt, wenn die Bedingung $a

Verwenden Sie globale Variablen

Verwenden Sie globale Variablen, um rekursive Funktionen auszuführen. Bitte stellen Sie sicher, dass Sie verstehen, was globale Variablen sind. Die innerhalb der Funktion deklarierte globale Variable ist lediglich eine Referenz auf die externe Variable mit demselben Namen. Der Gültigkeitsbereich der Variablen liegt weiterhin im Gültigkeitsbereich dieser Funktion. Wenn Sie die Werte dieser Variablen ändern, ändern sich natürlich auch die Werte externer Variablen mit demselben Namen. Aber sobald & verwendet wird, ist die Variable mit demselben Namen keine Referenz mit demselben Namen mehr. Es ist nicht erforderlich, eine so tiefe Ebene zu verstehen, um globale Variablen zum Implementieren rekursiver Funktionen zu verwenden. Sie können rekursive Funktionen auf natürliche Weise verstehen, indem Sie die ursprüngliche Ansicht globaler Variablen beibehalten.

<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>) {
        <span>$result</span>[]=<span>$a</span><span>;
        test(</span><span>$a,$result</span><span>);
    }
    </span><span>return</span><span>$result</span><span>;
}</span>

Verwendung statischer Variablen

Wir sehen oft statische Variablen in Klassen, heute verwenden wir sie in der Rekursivität Funktion. Denken Sie an die Rolle von Static: Initialisieren Sie die Variable nur beim ersten Aufruf der Funktion und behalten Sie den Variablenwert bei.

Zum Beispiel:

<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>

Ich würde gerne fragen über diesen Codeabschnitt Was ist das Ausführungsergebnis? Ist es 00000? Definitiv nicht. Es ist 01234. Rufen Sie test() zum ersten Mal auf, initialisiert statisch

$count und behält $count nach jeder Ausführung bei wird nicht mehr initialisiert, was dem direkten Ignorieren des Satzes static$count=0; entspricht.

Daher kann man sich den Effekt der Anwendung von Statik auf eine rekursive Funktion vorstellen. Variablen, die als „Brücken“ zwischen rekursiven Funktionen verwendet werden müssen, werden statisch initialisiert, und der Wert der „Brückenvariablen“ bleibt für jede Rekursion erhalten.

<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>) {
        <span>$result</span>[]=<span>$a</span><span>;
        test(</span><span>$a</span><span>);
    }
    </span><span>return</span><span>$result</span><span>;
}</span>

Zusammenfassung

Die sogenannte rekursive Funktion konzentriert sich darauf, wie der Funktionsaufruf selbst gehandhabt wird und wie sichergestellt wird, dass die erforderlichen Anforderungen erfüllt werden Ergebnisse können zwischen Funktionen übertragen werden. Vernünftige „Übertragung“, natürlich gibt es rekursive Funktionen, die keine Werteübertragung zwischen Funktionen erfordern, zum Beispiel:

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

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

Konfrontiert mit einer solchen Funktion , wir müssen uns darüber keine Sorgen machen. Übrigens kann ein tiefes Verständnis der Variablenreferenzen einen großen Beitrag zur Lösung dieser Art von Problemen leisten.

Das Obige stellt die drei Implementierungsmethoden rekursiver PHP-Funktionen vor, einschließlich der relevanten Inhalte. Ich hoffe, dass es für Freunde hilfreich ist, die sich für PHP-Tutorials interessieren.