Detaillierte JavaScript-Rekursion

1. Was ist Rekursion?

Wenn eine Funktion sich selbst intern aufrufen kann, dann ist diese Funktion rekursiv. Einfaches Verständnis: Eine Funktion ruft sich intern selbst auf und diese Funktion ist eine rekursive Funktion.

Wie unten dargestellt:

Funktion fn(){
 fn();
}
fn();

Diese Funktion ist eine rekursive Funktion. Wenn wir sie direkt drucken, wird sie:

Ich habe einen Druckfehler gefunden. Warum? Weil rekursive Funktionen die gleiche Wirkung haben wie Schleifen. Wenn ihm kein Rückgabewert gegeben wird, wird es in einer Endlosschleife fortgesetzt. Wir wissen also:

Da bei der Rekursion stack overflow auftreten können, muss eine return der Beendigungsbedingung hinzugefügt werden.

Wie schreibt man eine korrekte rekursive Funktion? Nehmen Sie den obigen Code als Beispiel: Wenn wir beispielsweise fünfmal „Hallo“ drucken möchten, sollten wir es folgendermaßen schreiben:

varnum = 1;
Funktion fn(){
            console.log('Hallo');
            wenn(Zahl == 5){
                zurückkehren;
            }
            Zahl++;
            fn();
        }
        fn();

Das Druckergebnis ist:

Nachdem wir nun wissen, was Rekursion ist, schauen wir uns an, wie man Rekursion zur Lösung von Problemen einsetzen kann.

2. Mathematische Probleme mit Rekursion lösen

1. Finden Sie die Fakultät von 1 * 2 * 3 * 4 …*n

Der Code lautet wie folgt:

 Funktion fn(n){
           wenn(n == 1){
               Rückgabe 1;
           }
           gibt n*fn(n-1) zurück;
       }
       console.log('Die Fakultät von 1-20 ist: '+fn(20));
       console.log('Die Fakultät von 1-10 ist: '+fn(10));
       console.log('Die Fakultät von 1-5 ist: '+fn(5));

Das Druckergebnis ist:

2. Finden Sie die Fibonacci-Folge

Die Fibonacci-Folge, auch als „Kaninchenfolge“ bekannt, bezeichnet eine Zahlenfolge ：、1、1、2、3、5、8、13、21、34、……， d. h. der Wert des dritten Terms ist die Summe der beiden vorhergehenden Terme. Der Benutzer gibt ein n ein und erhält die Nummer an dieser Position.

Der Code lautet wie folgt:

Funktion fb(n){
            wenn(n === 1 || n === 2){
                Rückgabe 1;
            }
            gibt fb(n-1) + fb(n-2) zurück;
        }
       console.log('Der Wert der dritten Fibonacci-Zahl ist: '+fb(3));
       console.log('Der Wert der 10. Fibonacci-Zahl ist: '+fb(10));

Das Druckergebnis ist:

3. Verwenden Sie Rekursion, um das entsprechende Datenobjekt zu finden

Gibt das entsprechende Datenobjekt entsprechend id zurück

Es gibt Objekte wie dieses:

        var Datum = [{
            Ich würde: 1,
            Name:'Elektrogeräte',
            Waren:[{
                Ich würde: 11,
                gname:'Mobiltelefon'
            },{
                Ich würde: 12,
                gname: 'Computer'
            }]
        },{
            Ich würde: 2,
            Name: 'Kleidung',
            Waren:[{
                Ich würde: 21,
                gname:'Hose'
            },{
                Ich würde: 22,
                gname: 'Mantel'
                }]
        },{
            ID: 3,
            Name: 'Essen'
                }];

Jetzt müssen wir das entsprechende Datenobjekt durch Eingabe id zurückgeben.

Zunächst können wir for...Each() verwenden, um das Array zu durchlaufen und jeden Wert abzurufen, wie unten gezeigt:

Funktion getId(Array,ID){
                    array.forEach(Funktion(Wert){
                        konsole.log(Wert);
                    })
                }
                getId(Datum,1);

Das ausgedruckte Ergebnis lautet:

Wenn wir jetzt den Wert des Objekts mit der ID 1 abrufen möchten, können wir Folgendes tun:

Funktion getId(Array,ID){
                    array.forEach(Funktion(Wert){
                       wenn(Wert.id === id){
                           konsole.log(Wert);
                       }
                    })
                }
                getId(Datum,1);

Das Druckergebnis ist:

Ja, aber was ist, wenn wir den Wert des Objekts mit der ID 11 abrufen möchten? Offensichtlich ist ein direkter Aufruf der Funktion nicht möglich, da wir über for...Each nur den Wert des äußersten Objekts abrufen, die spezifische Klassifizierung der inneren Ebene jedoch nicht erhalten. Zu diesem Zeitpunkt können wir den Wert des inneren Objekts abrufen, indem wir die Funktion getId(array,id) rekursiv aufrufen.

Die Funktionsweise ist wie folgt:

 Funktion getId(Array,ID){
                    array.forEach(Funktion(Wert){
                       wenn(Wert.id === id){
                           konsole.log(Wert);
                       }sonst wenn(Wert.Waren && Wert.Waren.Länge != 0){
                            getId(Wert.Waren,ID);
                       }

                    })
                }
                // getId(Datum,1);
                getId(Datum,11);

Das ausgedruckte Ergebnis lautet:

Dies ist das Ende dieses Artikels über JavaScript Rekursion. Weitere relevante Inhalte zur JavaScript-Rekursion finden Sie in den vorherigen Artikeln von 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, dass jeder 123WORDPRESS.COM in Zukunft unterstützen wird!