Der Unterschied zwischen Fehler und Ausnahme in JavaScript

https://github.com/Ray-D-Song

Fehler und Ausnahme sind Konzepte, die aus der Praxis stammen und darauf abzielen, mit „programmierbaren Fehlern“ umzugehen.

Fehler

Aus Code-Sicht werden Fehler in der Regel manuell und präzise behandelt.

Beispielsweise ruft fnA fnB und fnC auf. Bei beiden Methoden können Fehler auftreten. Der Verarbeitungscode lautet ungefähr wie folgt:

function fnA() {
  const { err: bErr, res: bRes } = fnB()
  if (bErr) {
    // ...
    // error handling
  }

  const { err: cErr, res: cRes } = fnC()
  if (cErr) {
    // ...
    // error handling
  }
  // normal logic
}

Der Schlüssel zu „Fehler“ besteht darin, ein Objekt oder Array von der Funktion zurückzugeben, wobei ein Feld „ein Fehler ist aufgetreten“ darstellt. Solange dieses Feld nicht leer ist, wissen Programmierer, dass der normale Ablauf unterbrochen wurde.

JavaScript verfügt über ein internes Error-Objekt und einen Konstruktor, aber das Feld, das den Fehler darstellt, muss kein Error-Objekt sein. Stattdessen wird das Error-Objekt häufiger bei der Ausnahmebehandlung verwendet.

Ausnahme

Wir haben bereits eine Fehlerbehandlung. Warum brauchen wir eine Ausnahme?

Stellen Sie sich ein Szenario vor, in dem Sie einen Knopf haben. Wenn auf die Schaltfläche geklickt wird, wird Funktion A ausgelöst. Nach dem Durchlaufen mehrerer Aufrufebenen (vielleicht 10 Ebenen) tritt in Funktion X ein Fehler auf. Sie möchten dem Benutzer keinen „unbekannten Fehler“ mitteilen, sondern ihn vielmehr bereitstellen spezifische Informationen darüber, was schief gelaufen ist.

Sie können diesen Effekt mit Fehlern erzielen, aber Sie müssen diesen Code zehnmal schreiben:

function fnA() {
  const { err, res } = fnB()
  if (err) {
    // display error to user
    showErr(err)
  }
}

function fnB() {
  const { err, res } = fnC()
  if (err)
    // propagate error
    return { err, null }
}

// ... 10 similar passes

function fnY() {
  const { err, res } = fnX()
  if (err)
    // propagate error
    return { err, null }
}

Diese Art von Boilerplate-Code ist sehr ineffizient. Eine bessere Methode ist die Verwendung von Ausnahmen.

Sie müssen nur dann eine Ausnahme auslösen, wenn in fnY ein Fehler auftritt. Auf der obersten Ebene können Sie es fangen.

function fnA() {
  try {
    fnB()
  } catch (e) {
    showErr(e)
  }
}

// ...

function fnY() {
  const { err, res } = fnX()
  if (err)
    // 抛出
    throw err
}

Auf diese Weise kann ein Fehler unabhängig davon, wo er auftritt, auf der obersten Ebene abgefangen werden und der Code in anderen Ebenen wird nicht beeinträchtigt.

Vermeiden Sie es, die gesamte Codestruktur an einer Stelle mit Fehlern zu verunreinigen.

Warum zwischen den beiden unterscheiden?

Wir haben bereits erklärt, warum wir Ausnahmen brauchen, aber warum müssen wir zwischen Fehlern und Ausnahmen unterscheiden?

Die beste Vorgehensweise besteht darin, strikt zwischen beiden zu unterscheiden. Wenn ein Fehler nicht Schicht für Schicht weitergegeben werden muss, sollte er direkt in der aktuellen Schicht behandelt werden. Beispielsweise muss der Fehler von fnC nicht in fnA verwendet werden, daher sollte er direkt in B als Fehler behandelt werden.

Angenommen, alle Fehler werden auf der obersten Ebene behandelt, dann wird die gesamte Logik im Catch-Block auf der obersten Ebene gestapelt, was schwer zu warten ist.

function main() {
  try {
    task1()
    task2()
    task3()
  } catch(e) {
    switch(e) {
      case "type A":
        //...
        break;
      case "type B":
        //...
        break;
      case "type C":
        //...
        break;
    }
  }
}

Das obige ist der detaillierte Inhalt vonDer Unterschied zwischen Fehler und Ausnahme in JavaScript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!