Maximale Call-Stack-Größe überschritten Fehler in JavaScript

1. Maximale Call-Stack-Größe überschritten Fehler in JavaScript
2. Rekursive Funktion in JavaScript
3. Korrigieren Sie eine rekursive Funktion in JavaScript
4. Finden Sie den Fehler in JavaScript

Der JavaScript-Fehler Maximale Call-Stack-Größe überschritten tritt auf, wenn eine Funktion so oft aufgerufen wird, dass die Aufrufe das maximale Call-Stack-Limit überschreiten.

Wenn der JavaScript-Fehler Maximale Call-Stack-Größe überschritten auftritt, liegt das Problem bei der rekursiven Funktion in Ihrem JavaScript-Code. Insbesondere liegt das Problem bei der Funktion, die sich immer wieder selbst aufruft.

Maximale Call-Stack-Größe überschritten Fehler in JavaScript

Wenn dieser Fehler auftritt, können Sie mehrere Schritte unternehmen, um den Codeabschnitt zu beheben, der alle verfügbaren Aufruflisten in einem Browser auffrisst.

Anhand dieses JavaScript-Artikels erfahren Sie ausführlich, warum der Fehler Maximale Call-Stack-Größe überschritten auftritt und was Sie dagegen tun können.

Alle JavaScript-Fehlerobjekte sind vom Error-Objekt abgeleitet oder geerbt. Dies wird als RangeError bezeichnet.

Ein RangeError weist oft auf einen Fehler ausserhalb des Argumentwerts eines Code-Parameters hin.

Nachdem Sie nun ein wenig wissen, wo dieser Fehler in den Bereich der JavaScript-Fehler fällt, fahren wir mit der Ursache des Fehlers Maximale Aufrufstapelgröße überschritten fort.

Dennoch müssen Sie die Rekursion verstehen, bevor Sie den Fehler Maximale Aufrufstapelgröße überschritten verstehen.

Rekursive Funktion in JavaScript

Rekursion ist ein Muster, bei dem eine definierte Funktion sich selbst aufruft, wobei jede Iteration Bedingungen näher an einen Basisfall verschiebt, der ein Entkommen aus den Funktionsaufrufen ermöglicht. Wenn Sie jedoch nicht aufpassen, kann sich eine Funktion kontinuierlich selbst aufrufen, bis der Stack des Browsers erschöpft ist.

Die häufigste Ursache für den Fehler Maximale Aufrufstapelgröße überschritten einer rekursiven Funktion ist ein Problem mit dem Basisfall oder dessen Fehlen. Wenn rekursiver Code seinen Basiscode nicht hat oder daran vorbeischießt, ruft er sich solange selbst auf, bis der Maximum Call Stack des Browsers erreicht ist.

Korrigieren Sie eine rekursive Funktion in JavaScript

Das Problem bei einer rekursiven Funktion, die sich weiterhin selbst aufruft, besteht darin, dass es unmöglich ist, innerhalb einer Kette zur folgenden Funktion zu wechseln, und Sie werden den gesamten Stack auffressen.

Das doppelte Überprüfen Ihrer rekursiven Funktionen ist der beste Ansatz, um dieses Problem zu vermeiden. Geben Sie dann zur Lösung des Problems einen Basisfall an, der erfüllt sein muss, um die Rekursion zu beenden.

Der folgende Screenshot zeigt, wie rekursiver Code aussieht, wenn er sich selbst auf unbestimmte Zeit aufruft.

function example() {
  // RangeError: Maximum call stack size exceeded
  example();
}
example();

Sie können die Funktion aufrufen, die sich selbst aufruft, bis das Call-Stack-Limit überschritten wird. Danach müssen Sie eine Bedingung angeben, bei der die Funktion aufhört, sich selbst aufzurufen, um den Fehler zu beheben.

let counter = 0;

function example(num) {
  if (num < 0) {
    return;
  }

  counter += 1;
  example(num - 1);
}

example(4);

console.log(counter);

Dieses Mal prüfen Sie, ob die Funktion bei jedem Aufruf mit einer Zahl kleiner als 0 aufgerufen wurde. Wenn die Zahl kleiner als 0 ist, kehren Sie von der Funktion zurück, sodass Sie das Limit des Aufrufstapels nicht überschreiten.

Wenn der übergebene Wert nicht kleiner als Null ist, rufen Sie die Funktion mit dem übergebenen Wert auf, der 1 ist. Dies wird Sie in Richtung des Falls bewegen, in dem die Wenn-Prüfung erfüllt ist.

Eine rekursive Funktion ruft sich selbst solange auf, bis eine Bedingung erfüllt ist. Wenn es beispielsweise keine Bedingung zum Abschließen Ihrer Funktion gibt, ruft sie sich selbst auf, bis die maximale Größe des Aufrufstapels überschritten ist.

Sie erhalten diesen Fehler, wenn Sie eine Endlosschleife haben, die eine Funktion aufruft.

function sum(x, y) {
  return x + y;
}

while (true) {
  sum(10, 10);
}

Die while-Schleife ruft die Funktion weiterhin auf, und da Sie keine Bedingung haben, die die Schleife verlassen würde, werden Sie schließlich die Größe des Aufrufstapels überschreiten.

Dies verhält sich ähnlich wie eine Funktion, die sich selbst ohne Grundbedingung aufruft. Dasselbe wäre beispielsweise der Fall, wenn Sie eine for-Schleife verwenden.

Nachfolgend finden Sie ein Beispiel dafür, wie Sie eine Bedingung angeben können, die erfüllt sein muss, um die Schleife zu verlassen.

function sum(x, y) {
  return x + y;
}

let total = 0;

for (let i = 10; i > 0; i--) {
  total += sum(5, 5);
}

console.log(total);

Die Bedingung in der for-Schleife ist nicht erfüllt, wenn die i-Variable gleich oder kleiner als 0 ist; somit verlassen Sie die Schleife.

Finden Sie den Fehler in JavaScript

Das Durchsuchen Ihrer Protokolle ist der erste Schritt zum Auffinden eines Fehlers, aber das Auffinden einer Zeile fehlerhaften Codes kann schwierig sein, wenn Sie mit Tausenden von Codezeilen arbeiten.

Der Fehler kann auch auftreten, wenn Sie dieselbe Datei mehrmals auf derselben Seite importieren, z. B. wenn Sie das jQuery-Skript mehrmals auf derselben Seite laden. Öffnen Sie die Registerkarte Netzwerk in den Entwicklertools Ihres Browsers und aktualisieren Sie die Seite, um zu sehen, welche Skripte auf Ihrer Website geladen werden.