Lassen Sie uns gemeinsam die Methoden zur Ausnahmebehandlung von JavaScript analysieren

Dieser Artikel vermittelt Ihnen relevantes Wissen über JavaScript und stellt vor allem Probleme im Zusammenhang mit der Ausnahmebehandlung vor. Durch diese Fehler können wir lernen, wie wir solche Fehler vermeiden können Schauen wir uns das nächste Mal besser an. Ich hoffe, es wird für alle hilfreich sein.

【Verwandte Empfehlungen: Javascript-Video-Tutorial, Web-Frontend】

Fehler sind Teil des Programmierprozesses. Beim Schreiben von Programmen treten zwangsläufig einige Fehler auf. Durch diese Fehler können wir lernen, solche Situationen zu vermeiden und es beim nächsten Mal besser zu machen.

Wenn in JavaScript Codeanweisungen eng miteinander verbunden sind und Fehler erzeugen, macht es keinen Sinn, die verbleibenden Codeanweisungen weiterhin zu verwenden. Stattdessen versuchen wir, Fehler so sanft wie möglich zu beheben. Wenn ein solcher Fehler auftritt, prüft der JavaScript-Interpreter den Ausnahmebehandlungscode. Wenn kein Ausnahmehandler vorhanden ist, kehrt das Programm zu der Funktion zurück, die den Fehler verursacht hat.

Wiederholen Sie dies für jede Funktion im Aufrufstapel, bis ein Ausnahmehandler gefunden oder die Funktion der obersten Ebene erreicht wird, was dazu führt, dass das Programm mit einem Fehler beendet wird und zum Absturz des Programms führt.

Generell gibt es zwei Möglichkeiten, damit umzugehen:

• Eine Ausnahme auslösen – Wenn zur Laufzeit ein Problem auftritt, das nicht sinnvoll behandelt werden kann, ist es besser, es auszulösen

function openFile(fileName) {
  if (!exists(fileName)) {
    throw new Error('找不到文件 ' + fileName)
  }
  // ...
}

• Abfangen von Ausnahmen – Ausgelöste Ausnahmen werden zur Laufzeit abgefangen und behandelt, wenn es sinnvoller ist

try {
  openFile('../test.js')
} catch(e) {
  // 优雅地处理抛出的期望
}

Schauen wir uns diese Vorgänge genauer an.

Ausnahme ausgelöst

Möglicherweise wird etwas wie „ReferenceError: specs is not definiert“ angezeigt. Dies stellt eine Ausnahme dar, die über eine throw-Anweisung ausgelöst wird.

Syntax

throw «value»
// 不要这样做
if (somethingBadHappened) {
  throw 'Something bad happened'
}

Es gibt keine Einschränkungen hinsichtlich der Datentypen, die als Ausnahmen ausgelöst werden können, aber JavaScript verfügt über spezielle integrierte Ausnahmetypen. Einer davon ist Error, wie Sie im vorherigen Beispiel gesehen haben. Diese integrierten Ausnahmetypen liefern uns mehr Details als die Ausnahmemeldung.

Error

Der Fehlertyp wird verwendet, um allgemeine Ausnahmen darzustellen. Dieser Ausnahmetyp wird am häufigsten zur Implementierung benutzerdefinierter Ausnahmen verwendet. Es stehen zwei integrierte Eigenschaften zur Verfügung.

• message – Der Inhalt, der als Parameter an den Error-Konstruktor übergeben wird. Beispiel: new Error('Dies ist eine Fehlermeldung'). Sie können über die Nachrichteneigenschaft auf die Nachricht zugreifen.

const myError = new Error('Error!!!')
console.log(myError.message) // Error!!!

• stack – Diese Eigenschaft gibt den Verlauf (Aufrufstapel) der Datei zurück, die den Fehler verursacht hat. Ganz oben im Stapel steht auch die Nachricht, gefolgt vom eigentlichen Stapel, beginnend mit dem letzten/isolierten Fehlerpunkt bis zur äußersten verantwortlichen Datei.

Error: Error!!!
    at <anonymous>:1:1

Hinweis: new Error('...') führt vor dem Auslösen keine Operation aus, d. h. throw new Error('error msg') erstellt eine Fehlerinstanz in JavaScript und stoppt die Ausführung des Skripts , es sei denn, Sie unternehmen etwas mit dem Fehler, beispielsweise indem Sie ihn abfangen.

Ausnahmen abfangen

Da wir nun wissen, was Ausnahmen sind und wie man sie auslöst, besprechen wir, wie wir verhindern können, dass sie unser Programm durchbrechen, indem wir sie abfangen.

try-catch-finally ist die einfachste Möglichkeit, Ausnahmen zu behandeln.

try {
  // 要运行的代码
} catch (e) {
  // 发生异常时要运行的代码
}
  
[ // 可选
  finally {
    // 无论发生异常都始终执行的代码
  }
]

In der Try-Klausel fügen wir Code hinzu, der möglicherweise eine Ausnahme generiert. Wenn eine Ausnahme auftritt, wird die Catch-Klausel ausgeführt.

Manchmal muss der Code ausgeführt werden, unabhängig davon, ob der Code eine Ausnahme generiert. In diesem Fall können wir den optionalen „final“-Block verwenden.

Auch wenn die Try- oder Catch-Klausel die Return-Anweisung ausführt, wird der Final-Block ausgeführt. Die folgende Funktion gibt beispielsweise „Endgültig ausführen“ zurück, da die final-Klausel das letzte ist, was ausgeführt wird.

function foo() {
  try {
    return true
  } finally {
    console.log('Execute finally')
  }
}

Wir verwenden Try-Catch, wenn die Richtigkeit des Codes nicht vorher überprüft werden kann.

const user = '{"name": "D.O", "age": 18}'
try {
  // 代码运行
  JSON.parse(params)
  // 在出现错误的情况下，其余的代码将永远无法运行
  console.log(params)
} catch (err) {
  // 在异常情况下运行的代码
  console.log(err.message) // params is not defined
}

Wie oben gezeigt, ist es nicht möglich, JSON.parse zu überprüfen, um ein Stringify-Objekt oder einen String zu erhalten, bevor der Code ausgeführt wird.

Hinweis: Sie können vom Programm generierte Ausnahmen und Laufzeitausnahmen abfangen, aber Sie können keine JavaScript-Syntaxfehler abfangen.

try-catch-finally kann nur Synchronisierungsfehler abfangen. Wenn wir versuchen, es mit asynchronem Code zu verwenden, wurde try-catch-finally möglicherweise ausgeführt, bevor der asynchrone Code seine Ausführung abschließt.

So behandeln Sie Ausnahmen in asynchronen Codeblöcken

Rückruffunktionen

Bei Verwendung von Rückruffunktionen (nicht empfohlen) erhalten wir normalerweise zwei Parameter wie unten gezeigt:

async function(code, (err, result) => {
  if (err) return console.error(err)
  console.log(result)
})

Wir können sehen, dass es zwei Parameter gibt: err und Ergebnis. Wenn ein Fehler vorliegt, entspricht der Parameter err dem Fehler und wir können ihn zur Ausnahmebehandlung auslösen.

在 if (err) 块中返回某些内容或将其他指令包装在 else 块中都很重要。否则，您可能会遇到另一个错误。例如，当您尝试访问 result.data 时，result 可能未定义。

Promises

使用 promises 的 then 或者 catch，我们可以通过将错误处理程序传递给 then 方法或使用 catch 子句来处理错误。

promise.then(onFulfilled, onRejected)

也可以使用 .catch(onRejected) 而不是 .then(null, onRejected) 添加错误处理程序，其工作方式相同。

让我们看一个 .catch 拒绝 Promise 的例子。

Promise.resolve('1')
  .then(res => {
    console.log(res) // 1
    throw new Error('go wrong') // 抛出异常
})
.then(res => {
  console.log(res) // 不会被执行
})
.catch(err => { 
  console.error(err) // 捕获并处理异常 ——> Error: go wrong
})

使用 async/await 和 try-catch

使用 async/await 和 try-catch-finally，处理异常是轻而易举的事。

async function func() {
  try {
    await nonExistentFunction()
  } catch (err) {
    console.error(err) // ReferenceError: nonExistentFunction is not defined 
  }
}

如何处理未捕获的异常

现在我们已经很好地理解了如何在同步和异步代码块中执行异常处理，让我们回答本文最后一个待解决的问题 ：我们如何处理未捕获的异常？

在浏览器中

我们可以使用 window.onerror() 方法来处理未捕获的异常。每当运行时发生错误时，该方法会在 window 对象上触发 error 事件。

onerror() 的另一个实用做法是：当站点中的图片或视频等数据加载出错时，可以用该方法触发某些操作。例如，提供一张加载出错时的图片，或显示一条消息。

<img src="logo.png" onerror="alert(&#39;Error loading picture.&#39;)" />

在 Node.js 中

EventEmitter 模块派生的 process 对象可以订阅事件 uncaughtException。

process.on('uncaughtException', () => {})`

我们可以传递一个回调来处理异常。如果我们尝试捕获这个未捕获的异常，进程将不会终止，因此我们必须手动完成。

uncaughtException 仅适用于同步代码。对于异步代码，还有另一个称为 unhandledRejection 的事件。

process.on('unhandledRejection', () => {})

决不要尝试为基本 Error 类型实现 “捕获所有” 处理程序。这将混淆所发生的一切，并损害代码的可维护性和可扩展性。

关键要点

throw 语句用于生成用户定义的异常。在运行时，当 throw 遇到语句时，当前函数的执行将停止，控制权将传递给 catch 调用堆栈中的第一个子句。如果没有 catch 子句，程序将终止

JavaScript 有一些内置的异常类型，最值得注意的是 Error，它返回 Error 中的两个重要属性：stack 和 message。

try 子句将包含可能产生异常的代码，catch 子句会在发生异常时执行。

对于异步代码，最好使用 async/await 配合 try-catch 语句。

可以捕获未处理的异常，这可以防止应用程序崩溃。

不要觉得麻烦，异常处理可以帮助您提高代码的可维护性、可扩展性和可读性。

【相关推荐：javascript视频教程、web前端】

Das obige ist der detaillierte Inhalt vonLassen Sie uns gemeinsam die Methoden zur Ausnahmebehandlung von JavaScript analysieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!