InternalError: zu viel Rekursion

Die JavaScript-Ausnahme „zu viel Rekursion“ oder „Maximale Aufrufstapelgröße überschritten“ tritt auf, wenn es zu viele Funktionsaufrufe gibt oder eine Funktion einen Basisfall vermisst.

In diesem Artikel

Nachricht

RangeError: Maximum call stack size exceeded (Chrome) InternalError: too much recursion (Firefox) RangeError: Maximum call stack size exceeded. (Safari)

Fehlertyp

InternalError in Firefox; RangeError in Chrome und Safari.

Eine Funktion, die sich selbst aufruft, wird als rekursive Funktion bezeichnet. Sobald eine Bedingung erfüllt ist, hört die Funktion auf, sich selbst aufzurufen. Dies wird als Basisfall bezeichnet.

In gewisser Weise ist Rekursion analog zu einer Schleife. Beide führen denselben Code mehrfach aus und beide benötigen eine Bedingung (um eine Endlosschleife bzw. in diesem Fall eine endlose Rekursion zu vermeiden). Wenn es zu viele Funktionsaufrufe gibt oder eine Funktion einen Basisfall vermisst, wirft JavaScript diesen Fehler.

Beispiele

Diese rekursive Funktion läuft 10 Mal, gemäß der Abbruchbedingung.

js
function loop(x) {
  if (x >= 10)
    // "x >= 10" is the exit condition
    return;
  // do stuff
  loop(x + 1); // the recursive call
}
loop(0);

Das Setzen dieser Bedingung auf einen extrem hohen Wert funktioniert nicht:

js
function loop(x) {
  if (x >= 1000000000000) return;
  // do stuff
  loop(x + 1);
}
loop(0);

// InternalError: too much recursion

Diese rekursive Funktion fehlt ein Basisfall. Da es keine Abbruchbedingung gibt, wird die Funktion sich unendlich oft selbst aufrufen.

js
function loop(x) {
  // The base case is missing
  loop(x + 1); // Recursive call
}

loop(0);

// InternalError: too much recursion

Klassischer Fehler: zu viel Rekursion

js
class Person {
  constructor() {}
  set name(name) {
    this.name = name; // Recursive call
  }
}

const tony = new Person();
tony.name = "Tonisha"; // InternalError: too much recursion

Wenn ein Wert der Eigenschaft name zugewiesen wird (this.name = name;), muss JavaScript diese Eigenschaft setzen. Wenn dies geschieht, wird die Setter-Funktion ausgelöst.

In diesem Beispiel wird bei Auslösen des Setters derselbe Vorgang erneut angewiesen: die gleiche Eigenschaft zu setzen, die es zu bearbeiten gilt. Dies führt dazu, dass die Funktion sich selbst immer und immer wieder aufruft und dadurch unendlich rekursiv wird.

Dieses Problem tritt auch auf, wenn dieselbe Variable im Getter verwendet wird.

js
class Person {
  get name() {
    return this.name; // Recursive call
  }
}

Um dieses Problem zu vermeiden, stellen Sie sicher, dass die Eigenschaft, die innerhalb der Setter-Funktion zugewiesen wird, sich von der unterscheidet, die den Setter ursprünglich ausgelöst hat. Gleiches gilt für den Getter.

js
class Person {
  constructor() {}
  set name(name) {
    this._name = name;
  }
  get name() {
    return this._name;
  }
}
const tony = new Person();
tony.name = "Tonisha";
console.log(tony);

Siehe auch

Help improve MDN

War diese Übersetzung hilfreich?

Ja Nein

Erfahren Sie, wie Sie beitragen können Diese Seite wurde automatisch aus dem Englischen übersetzt.

Übersetzung auf GitHub anzeigen • Fehler mit dieser Übersetzung melden