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.

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.

Was ist schiefgelaufen?

Eine Funktion, die sich selbst aufruft, wird alsrekursive Funktion bezeichnet. Sobald eine Bedingung erfüllt ist, hört die Funktion auf, sich selbst aufzurufen. Dies wird alsBasisfall 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.

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:

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.

function loop(x) {  // The base case is missing  loop(x + 1); // Recursive call}loop(0);// InternalError: too much recursion

Klassischer Fehler: zu viel Rekursion

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

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.

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

• Rekursion
• Rekursive Funktionen