Rekursion im funktionalen JavaScript

Sie haben vielleicht von rekursiven Funktionen in JavaScript gehört und sogar versucht, einige zu schreiben. Möglicherweise haben Sie jedoch nicht viele Beispiele für Rekursion gesehen, die tatsächlich funktionieren. In der Tat haben Sie neben der Besonderheit dieses Ansatzes möglicherweise nicht darüber nachgedacht, wann und wo die Rekursion nützlich ist oder wie gefährlich sie ist, wenn sie unsachgemäß verwendet.

Schlüsselpunkte

• Rekursion ist eine JavaScript -Methode, mit der die Funktion sich wiederholt aufruft, bis das Ergebnis erreicht ist. Es ist besonders nützlich für Probleme, die iterative Zweige wie fraktaler Mathematik, Sortieren oder Durchqueren komplexer oder nichtlinearer Datenstrukturen betreffen.
• Während die Rekursion den Code prägnanter und leicht verständlicher machen kann, kann er bei unsachgemäßer Verwendung gefährlich sein, da das Risiko der Speicherkapazität des Motors überschreitet. Dies liegt daran, dass die rekursiven JavaScript -Funktionen bei jedem Mal nachverfolgen müssen, wo sie aufgerufen werden, damit sie weiterhin am richtigen Ort ausführen können.
• In vielen funktionalen Programmiersprachen wird eine Technik namens Tail Call -Optimierung verwendet, um Rekursion zu verwalten. Dies ermöglicht jede kontinuierliche Schleife in der rekursiven Funktion sofort, anstatt sich im Gedächtnis zu stapeln. Die meisten JavaScript -Compiler sind dafür noch nicht optimiert.
• benutzerdefinierte Bounce -Funktionen können so erstellt werden, dass die rekursive Ausführung iterativ verwaltet wird, sodass jeweils nur jeweils nur einen Betrieb auf dem Stapel bleibt. Dies kann dazu beitragen, tiefe Stapeloperationen zu erstellen, die darauf warten, ausgeführt zu werden, aber normalerweise auf Kosten von Leistung und Lesbarkeit.

Zweck der Rekursion

Rekursion ist eine Technik, die den Betrieb durch den Betrieb durchführt, indem sich ein Funktion wiederholt selbst aufgerufen hat, bis das Ergebnis erzielt wird. Die meisten Schleifen können in rekursiven Stilen umgeschrieben werden, und in einigen funktionalen Programmiersprachen ist diese Schleifenmethode die Standardmethode.

Während der funktionale Programmierstil von JavaScript rekursive Funktionen unterstützt, müssen wir jedoch erkennen, dass die meisten JavaScript -Compiler derzeit nicht sicher für sie optimiert sind.

Rekursion wird am besten verwendet, wenn Sie die gleiche Funktion wiederholt mit unterschiedlichen Parametern in der Schleife aufrufen müssen. Während es in vielen Fällen verwendet werden kann, ist es am effektivsten, Probleme mit iterativen Zweigen wie fraktaler Mathematik, Sortieren oder Durchqueren von Knoten komplexer oder nichtlinearer Datenstrukturen zu lösen.

Einer der Gründe, warum die Rekursion in funktionalen Programmiersprachen bevorzugt wird, ist, dass das Erbaus ermöglicht, dass die Verwendung lokaler Variablen nicht den Zustand festgelegt und aufrechterhalten wird. Rekursive Funktionen sind ebenfalls leicht zu testen, da sie einfach auf reine Weise zu schreiben, einen spezifischen und konsistenten Rückgabewert für eine bestimmte Eingabe aufweisen und keine Nebenwirkungen auf den Zustand der externen Variablen haben.

Zyklus

Ein klassisches Funktionsbeispiel, das eine Rekursion angewendet werden kann, ist faktorisch. Dies ist eine Funktion, die das Ergebnis einer Zahl zurückgibt, die wiederholt von jeder vorherigen Ganzzahl bis 1 multipliziert wird.

zum Beispiel ist das Faktor von 3:

<code>3 × 2 × 1 = 6</code>

Das Faktor für

6 ist:

<code>3 × 2 × 1 = 6</code>

Sie können sehen, wie schnell diese Ergebnisse größer werden. Sie können auch sehen, wie wir das gleiche Verhalten immer wieder wiederholen. Wir nehmen das Ergebnis eines Multiplikationsvorgangs und multiplizieren sie mit dem zweiten Wert mit minus 1. Dann machen wir das immer wieder, bis wir 1 erreichen.

Verwenden einer für die Schleife, ist es nicht schwierig, eine Funktion zu erstellen, die dies durchführt, bis das richtige Ergebnis zurückgegeben wird:

<code>6 × 5 × 4 × 3 × 2 × 1 = 720</code>

Dies funktioniert, aber aus funktionaler Programmierung ist es nicht elegant. Um die für Schleife zu unterstützen und dann das Ergebnis zurückzugeben, müssen wir mehrere lokale Variablen verwenden, die den Staat pflegen und verfolgen. Wäre es nicht prägnanter, wenn wir die für Schleife verwerfen und eine funktionalere JavaScript -Methode anwenden könnten?

Rekursion

Wir wissen, dass JavaScript es uns ermöglicht, Funktionen zu schreiben, die Funktionen als Parameter betrachten. Was ist, wenn wir die tatsächliche Funktion verwenden möchten, die wir schreiben und sie im Kontext ausführen, in dem wir sie ausführen?

Ist das überhaupt möglich? Sicher! Betrachten Sie beispielsweise eine so einfache während der Schleife:

var factor = function(number) {
  var result = 1;
  var count;
  for (count = number; count > 1; count--) {
    result *= count;
  }
  return result;
};
console.log(factor(6));
// 720

Nachdem dies erledigt ist, hat sich der Wert des Zählers geändert, aber die Schleife hat seine Aufgabe zum Drucken jedes Wertes abgeschlossen, da wir den Zustand langsam aus ihm extrahiert haben.

rekursive Versionen derselben Schleife können eher so aussehen:

var counter = 10;
while(counter > 0) {
    console.log(counter--);
}

Haben Sie gesehen, wie wir die Countdown -Funktion direkt in der Definition der Countdown -Funktion aufrufen? JavaScript behandelt es wie ein Chef und tut nur das, was Sie wollen. Jedes Mal, wenn Countdown ausgeführt wird, verfolgt JavaScript, wo es aufgerufen wird, und kehrt dann zum Stapel dieses Funktionsaufrufs zurück, bis er fertig ist. Unsere Funktion vermeidet auch das Ändern des Zustands einer Variablen, verwendet jedoch die übergebenen Werte, um die Rekursion zu steuern.

Zurück zu unserem faktoriellen Fall können wir die vorherige Funktion wie diese umschreiben, um Rekursion zu verwenden:

var countdown = function(value) {
    if (value > 0) {
        console.log(value);
        return countdown(value - 1);
    } else {
        return value;
    }
};
countdown(10);

Auf diese Weise das Schreiben von Code ermöglicht es uns, den gesamten Prozess auf staatenlose Weise ohne Nebenwirkungen zu beschreiben. Es ist auch erwähnenswert, dass wir zuerst die Werte der an die Funktion übergebenen Parameter testen und dann alle Berechnungen durchführen. Wir möchten, dass jede Funktion, die sich anrufen soll, schnell und sauber, wenn sie ihre Kündigung erreicht. Für die auf diese Weise berechnete Faktorien, wenn die eingehende Zahl Null oder negativ ist, wird die Terminierungssituation erreicht (wir können auch negative Werte testen und verschiedene Nachrichten zurückgeben, wenn wir möchten).

Schwanzaufrufoptimierung

Eines der Probleme mit zeitgenössischen JavaScript -Implementierungen besteht darin, dass sie keine Standardmethode haben, um zu verhindern, dass rekursive Funktionen sich unendlich gestapelt und Speicher verbrauchen, bis sie die Kapazität der Motor überschreiten. Rekursive Funktionen von JavaScript müssen verfolgen, wo sie von jedem Mal aufgerufen werden, damit sie weiterhin am richtigen Ort ausführen können.

In vielen funktionalen Programmiersprachen wie Haskell und Schema wird dies anhand einer Technik bezeichnet, die als Tail -Call -Optimierung bezeichnet wird. Mithilfe der Schwanzaufrufoptimierung tritt jede kontinuierliche Schleife in der rekursiven Funktion sofort auf, anstatt sich im Speicher zu erheben.

theoretisch ist die Tail -Call -Optimierung Teil des ECMascript 6 (der nächsten Version des aktuellen JavaScript) -Standards, die meisten Plattformen haben es jedoch noch nicht vollständig implementiert.

Bounce -Funktion

Bei Bedarf gibt es Möglichkeiten, JavaScript zu erzwingen, um rekursive Funktionen auf sichere Weise auszuführen. Beispielsweise können benutzerdefinierte Bounce -Funktionen so erstellt werden, dass die rekursive Ausführung iterativ verwaltet wird, sodass jeweils nur jeweils jeweils einen Betrieb auf dem Stapel bleiben. Die auf diese Weise verwendete Absprungfunktion kann die Fähigkeit von JavaScript nutzen, Funktionen an einen bestimmten Kontext zu binden, um die rekursive Funktion wieder an sich selbst abzuprallen und das Ergebnis jeweils einzeln aufzubauen, bis die Schleife abgeschlossen ist. Dadurch wird es vermeiden, tiefe Stapeloperationen zu erstellen, die auf die Ausführung warten.

In der Tat reduziert die Verwendung einer Sprungfunktion häufig die Leistung für die Sicherheit. Darüber hinaus geht der größte Teil der Eleganz und der Lesbarkeit, die wir durch das Schreiben von Funktionen erhalten, in der Codes -Faltung verloren, um diesen Ansatz in JavaScript zu bewirken.

Wenn Sie neugierig sind, ermutige ich Sie, mehr über dieses Konzept zu lesen und Ihre Gedanken in der folgenden Diskussion zu teilen. Sie können mit einem kurzen Thema zum Stackoverflow beginnen und einige Artikel von Don Taylor und Mark McDonnell erkunden, die tiefer in die Vor- und Nachteile der Sprung von Funktionen in JavaScript eingehen.

Wir sind noch nicht an diesem Punkt

Rekursion ist eine leistungsstarke Technik, die es wert ist, zu wissen. In vielen Fällen ist Rekursion der einfachste Weg, um komplexe Probleme zu lösen. Bevor ECMascript 6 jedoch vollständig mit der Schwanzanrufoptimierung implementiert wird, wo wir sie benötigen, müssen wir sehr vorsichtig sein, wie und wo die rekursive Anwendung angewendet wird.

FAQs über Rekursion im funktionalen JavaScript (FAQs)

Was ist die grundlegende Situation in der Rekursion? Warum ist es wichtig?

Die grundlegende Situation in der Rekursion ist die Erkrankung, die verhindert, dass die Funktion sich unendlich aufruft. Es ist entscheidend, weil sich die rekursive Funktion ohne sie unendlich nennt und einen Stapelüberlauffehler verursacht. Die grundlegende Situation ist in der Regel die Bedingung, dass eine Funktion vor dem rekursiven Anruf überprüft. Wenn diese Bedingung erfüllt ist, gibt die Funktion einen Wert zurück und hört auf, sich selbst anzurufen.

Wie funktioniert Rekursion in JavaScript?

In JavaScript funktioniert Rekursion, indem die Funktion selbst aufgerufen wird, bis die grundlegende Situation erreicht ist. Die Funktion ist in einen Grundfall und einen rekursiven Fall unterteilt. Der Grundfall gibt einen Wert zurück, ohne die Funktion erneut aufzurufen, während der rekursive Fall die Funktion erneut mit unterschiedlichen Parametern aufruft. Die Funktion ruft sich weiterhin auf, bis der Basisfall erreicht ist. Zu diesem Zeitpunkt beginnt sie den Wert zurückzugeben.

Was ist die Schwanzrekursion in JavaScript?

Schwanzrekursion ist eine spezielle Art von Rekursion, bei der der rekursive Anruf die letzte Operation in der Funktion ist. Dies ist wichtig, da es die Optimierung der JavaScript -Engine -Optimierung mithilfe einer Technik namens Tail Call -Optimierung wieder aufnehmen kann. Dies kann die von der Funktion verwendete Speichermenge erheblich reduzieren und es ermöglichen, größere Eingänge zu verarbeiten.

Was sind die Vor- und Nachteile der Verwendung von Rekursion in JavaScript?

Rekursion kann den Code prägnanter und leicht verständlicher machen, indem komplexe Probleme in einfachere Probleme auftreten. Es ist besonders nützlich für Aufgaben wie das Durchqueren von Baumdatenstrukturen. Die Rekursion kann jedoch auch weniger effizient sein als iterative Lösungen, und wenn sie falsch implementiert werden, kann dies zu einem Stapelüberlauffehler führen.

Wie vermeiden Sie Stapelüberlauffehler in rekursiven Funktionen?

Wenn sich die rekursive Funktion zu oft aufruft und den Anrufstapel füllt, tritt ein Stapelüberlauffehler auf. Um dies zu vermeiden, stellen Sie sicher, dass Ihre rekursive Funktion den Grundfall hat, der letztendlich erreicht wird. Erwägen Sie auch die Verwendung der Schwanzrekursion, die die JavaScript -Engine optimieren kann, um weniger Speicher zu verwenden.

Wie wird Rekursion in der funktionalen Programmierung verwendet?

In der funktionellen Programmierung wird die Rekursion häufig als Ersatz für Schleifen verwendet. Da die Funktionsprogrammierung die Verwendung variabler Zustände abhält, kann Rekursion verwendet werden, um wiederholte Operationen auszuführen, ohne Zustände zu ändern.

Können alle rekursiven Funktionen in iterative Funktionen umgewandelt werden?

Ja, theoretisch können alle rekursiven Funktionen in iterative Funktionen umgewandelt werden. Iterative Versionen können jedoch komplexer und schwieriger zu verstehen sein, insbesondere für Funktionen, die komplexe Baum- oder Graphen -Traverals betreffen.

Was ist gegenseitige Rekursion in JavaScript?

gegenseitige Rekursion bezieht sich auf zwei oder mehr Funktionen, die in einer Schleife miteinander aufgerufen werden. Dies mag eine leistungsstarke Technik sein, um bestimmte Arten von Problemen zu lösen, aber es kann auch schwieriger sein, zu verstehen und zu debuggen als eine einfache Rekursion.

Wie kann rekursive Funktionen in JavaScript debuggen?

rekursive Funktionen abtropfen können aufgrund wiederholter Funktionsaufrufe eine Herausforderung sein. Es kann jedoch hilfreich sein, die Parameter der Funktion in jedem Schritt mit der Anweisung console.log zu drucken und Werte zurückzugeben. Darüber hinaus ist es sehr nützlich, ein Debugger -Tool zu verwenden, mit dem Sie Schritt -für -Schritt -Funktionsaufrufe ausführen können.

Gibt es Leistungsüberlegungen bei der Verwendung von Rekursion?

Ja, eine rekursive Funktion ist möglicherweise nicht so effizient wie das iterative Gegenstück aufgrund des Overhead von wiederholten Funktionsaufrufen. Wenn sie sich zu oft nennen, können sie auch einen Stapelüberlauffehler verursachen. In vielen Fällen kann die Lesbarkeit und Einfachheit einer rekursiven Lösung diese Leistungsüberlegungen jedoch überwiegen.

Das obige ist der detaillierte Inhalt vonRekursion im funktionalen JavaScript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!