Zusammenfassung der korrekten Fehlerbehandlung in JavaScript

In diesem Artikel wird die Fehlerbehandlung in clientseitigem JavaScript erläutert. Führt hauptsächlich häufige Fehler, Fehlerbehandlung, asynchrones Codeschreiben usw. in JavaScript ein. Werfen wir einen Blick darauf, wie Fehler in JavaScript richtig behandelt werden

Das ereignisgesteuerte Paradigma von JavaScript fügt eine reichhaltige Sprache hinzu und macht die Programmierung in JavaScript vielfältiger. Wenn Sie sich den Browser als ereignisgesteuertes Tool für JavaScript vorstellen, wird beim Auftreten eines Fehlers ein Ereignis ausgelöst. Theoretisch ist es möglich, anzunehmen, dass es sich bei diesen Fehlern lediglich um einfache Ereignisse in JavaScript handelt.

In diesem Artikel wird die Fehlerbehandlung in clientseitigem JavaScript erläutert. Führt hauptsächlich häufige Fehler, Fehlerbehandlung, asynchrones Codeschreiben usw. in JavaScript ein.

Sehen wir uns an, wie man Fehler in JavaScript richtig behandelt.

Demo

Die in diesem Artikel verwendete Demo finden Sie auf GitHub. Nach der Ausführung sieht die Seite so aus:

Jede Schaltfläche löst einen „Fehler (Ausnahme)“ aus, und dieser Fehler simuliert eine ausgelöste Ausnahme TypeError. Hier ist die Moduldefinition:

// scripts/error.js
function error() {
 var foo = {};
 return foo.bar();
}

Zuerst deklariert diese Funktion ein leeres Objekt foo. Beachten Sie, dass bar() nirgendwo definiert ist. Überprüfen Sie als Nächstes, ob dieser Komponententest einen „Fehler“ auslöst:

// tests/scripts/errorTest.js
it('throws a TypeError', function () {
 should.throws(error, TypeError);
});

Dieser Komponententest ist in Mocha und es gibt eine Testdeklaration in Should.js. Mocha ist das Test-Runner-Tool und Should.js ist die Assertion-Bibliothek. Dieser Unit-Test läuft auf Node und erfordert keinen Browser.

error() definiert ein leeres Objekt und versucht dann, auf eine Methode zuzugreifen. Da bar() im Objekt nicht vorhanden ist, wird eine Ausnahme ausgelöst. Dieser Fehler, der in dynamischen Sprachen wie JavaScript auftritt, kann jedem passieren!

Fehlerbehandlung (1)

Verwenden Sie den folgenden Code, um den obigen Fehler zu behandeln:

// scripts/badHandler.js
function badHandler(fn) {
 try {
  return fn();
 } catch (e) { }
 return null;
}

Der Handler verwendet fn als Eingabeparameter und dann wird fn innerhalb der Handlerfunktion aufgerufen. Unit-Tests spiegeln die Rolle des oben genannten Fehlerhandlers wider:

// tests/scripts/badHandlerTest.js
it('returns a value without errors', function() {
 var fn = function() {
  return 1;
 };
 var result = badHandler(fn);
 result.should.equal(1);
});

it('returns a null with errors', function() {
 var fn = function() {
  throw new Error('random error');
 };
 var result = badHandler(fn);
 should(result).equal(null);
});

Wenn ein Problem auftritt, gibt der Fehlerhandler null zurück. Die Rückruffunktion fn() kann auf eine zulässige Methode oder einen Fehler verweisen.

Die folgenden Klickereignisse setzen die Ereignisverarbeitung fort:

// scripts/badHandlerDom.js
(function (handler, bomb) {
 var badButton = document.getElementById('bad');
 if (badButton) {
  badButton.addEventListener('click', function () {
   handler(bomb);
   console.log('Imagine, getting promoted for hiding mistakes');
  });
 }
}(badHandler, error));

Diese Verarbeitungsmethode verbirgt einen Fehler im Code und ist schwer zu finden. Versteckte Fehler können stundenlange Fehlerbehebungszeit in Anspruch nehmen. Insbesondere bei mehrschichtigen Lösungen mit tiefen Aufrufstapeln kann es schwieriger sein, diesen Fehler zu finden. Das ist also eine sehr schlechte Art, mit Fehlern umzugehen.

Fehlerbehandlung (2)

Das Folgende ist eine weitere Methode zur Fehlerbehandlung.

// scripts/uglyHandler.js
function uglyHandler(fn) {
 try {
  return fn();
 } catch (e) {
  throw new Error('a new error');
 }
}

Die Art und Weise, Ausnahmen zu behandeln, ist wie folgt:

// tests/scripts/uglyHandlerTest.js
it('returns a new error with errors', function () {
 var fn = function () {
  throw new TypeError('type error');
 };
 should.throws(function () {
  uglyHandler(fn);
 }, Error);
});

Der obige Fehlerbehandler Dort sind offensichtliche Verbesserungen. Hier wird die Ausnahme den Aufrufstapel aufblasen. Gleichzeitig wird durch den Fehler der Stapel erweitert, was beim Debuggen sehr hilfreich ist. Zusätzlich zum Auslösen einer Ausnahme sucht der Interpreter nach zusätzlicher Verarbeitung im Stapel. Dies birgt auch die Möglichkeit, Fehler von oben im Stapel zu behandeln. Dies ist jedoch immer noch eine schlechte Fehlerbehandlung, da wir die ursprüngliche Ausnahme Schritt für Schritt im Stapel nachverfolgen müssen.

Eine Alternative zu dieser schlechten Fehlerbehandlung ist die Verwendung einer benutzerdefinierten Fehlermethode. Dieser Ansatz wird hilfreich, wenn Sie dem Fehler weitere Details hinzufügen.

Zum Beispiel:

// scripts/specifiedError.js
// Create a custom error
var SpecifiedError = function SpecifiedError(message) {
 this.name = 'SpecifiedError';
 this.message = message || '';
 this.stack = (new Error()).stack;
};
SpecifiedError.prototype = new Error();
SpecifiedError.prototype.constructor = SpecifiedError;
// scripts/uglyHandlerImproved.js
function uglyHandlerImproved(fn) {
 try {
  return fn();
 } catch (e) {
  throw new SpecifiedError(e.message);
 }
}
// tests/scripts/uglyHandlerImprovedTest.js
it('returns a specified error with errors', function () {
 var fn = function () {
  throw new TypeError('type error');
 };
 should.throws(function () {
  uglyHandlerImproved(fn);
 }, SpecifiedError);
});

Der angegebene Fehler fügt weitere Details hinzu und behält die ursprüngliche Fehlermeldung bei. Mit dieser Verbesserung ist die obige Verarbeitung keine schlechte Verarbeitungsmethode mehr, sondern eine klare und nützliche Methode.

Nach der oben genannten Verarbeitung haben wir auch eine nicht behandelte Ausnahme erhalten. Schauen wir uns als Nächstes an, wie Browser bei der Fehlerbehandlung helfen können.

Erweitern Sie den Stapel

Eine Möglichkeit, Ausnahmen zu behandeln, besteht darin, oben im Aufrufstapel einen try...catch hinzuzufügen.

Zum Beispiel:

function main(bomb) {
 try {
  bomb();
 } catch (e) {
  // Handle all the error things
 }
}

Browser sind jedoch ereignisgesteuert und Ausnahmen in JavaScript sind ebenfalls Ereignisse. Wenn eine Ausnahme auftritt, unterbricht der Interpreter die Ausführung und erweitert:

// scripts/errorHandlerDom.js
window.addEventListener('error', function (e) {
 var error = e.error;
 console.log(error);
});

Dieser Ereignishandler fängt alle Fehler ab, die im Ausführungskontext auftreten. Fehlerereignisse, die auf verschiedenen Zielen auftreten, können verschiedene Arten von Fehlern auslösen. Diese zentralisierte Fehlerbehandlung im Code ist sehr aggressiv. Sie können Daisy-Chaining verwenden, um bestimmte Fehler zu behandeln. Wenn Sie die SOLID-Prinzipien befolgen, können Sie die Fehlerbehandlung für einen einzigen Zweck nutzen. Diese Handler können jederzeit registriert werden, und der Interpreter durchläuft die Handler, die ausgeführt werden müssen. Die Codebasis kann aus dem try...catch-Block freigegeben werden, was auch das Debuggen erleichtert. In JavaScript ist es wichtig, die Fehlerbehandlung als Ereignisbehandlung zu behandeln.

捕获堆栈

在解决问题时，调用堆栈会非常有用，同时浏览器正好可以提供这些信息。虽然堆栈属性不是标准的一部分，但是最新的浏览器已经可以查看这些信息了。

下面是在服务器上记录错误的示例：

// scripts/errorAjaxHandlerDom.js
window.addEventListener('error', function (e) {
 var stack = e.error.stack;
 var message = e.error.toString();
 if (stack) {
  message += '\n' + stack;
 }
 var xhr = new XMLHttpRequest();
 xhr.open('POST', '/log', true);
 // Fire an Ajax request with error details
 xhr.send(message);
});

每个错误处理都具有单个目的，这样可以保持代码的DRY原则（目的单一，不要重复自己原则）。

在浏览器中，需要将事件处理添加到DOM。这意味着如果你正在构建第三方库，那么你的事件会与客户端代码共存。window.addEventListener( )会帮你进行处理，同时也不会抹去现有的事件。

这是服务器上日志的截图：

可以通过命令提示符查看日志，但是Windows上，日志是非动态的。

通过日志可以清楚的看到，具体什么情况触发了什么错误。在调试时调用堆栈也会非常有用，所以不要低估调用堆栈的作用。

在JavaScript中，错误信息仅适用于单个域。因为在使用来自不用域的脚本时，将会看不到任何错误详细信息。

一种解决方案是重新抛出错误，同时保留错误消息：

一旦重新启动了错误备

try {
 return fn();
} catch (e) {
 throw new Error(e.message);
}

份，全局错误处理程序就会完成其余的工作。确保你的错误处理处在相同域中，这样会保留原始消息，堆栈和自定义错误对象。

异步处理

JavaScript在运行异步代码时，进行下面的异常处理，会产生一个问题：

// scripts/asyncHandler.js
function asyncHandler(fn) {
 try {
  // This rips the potential bomb from the current context
  setTimeout(function () {
   fn();
  }, 1);
 } catch (e) { }
}

通过单元测试来查看问题：

// tests/scripts/asyncHandlerTest.js
it('does not catch exceptions with errors', function () {
 // The bomb
 var fn = function () {
  throw new TypeError('type error');
 };
 // Check that the exception is not caught
 should.doesNotThrow(function () {
  asyncHandler(fn);
 });
});

这个异常没有被捕获，我们通过单元测试来验证。尽管代码包含了try...catch，但是try...catch语句只能在单个执行上下文中工作。当异常被抛出时，解释器已经脱离了try...catch，所以异常未被处理。Ajax调用也会发生同样的情况。

所以，一种解决方案是在异步回调中捕获异常：

setTimeout(function () {
 try {
  fn();
 } catch (e) {
  // Handle this async error
 }
}, 1);

这种做法会比较奏效，但仍有很大的改进空间。

首先，这些try...catch block在整个区域纠缠不清。事实上，V8浏览器引擎不鼓励在函数内使用try ... catch block。V8是Chrome浏览器和Node中使用的JavaScript引擎。一种做法是将try...catch block移动到调用堆栈的顶部，但这却不适用于异步代码编程。

由于全局错误处理可以在任何上下文中执行，所以如果为错误处理添加一个窗口对象，那么就能保证代码的DRY和SOLID原则。同时全局错误处理也能保证你的异步代码很干净。

以下是该异常处理在服务器上的报告内容。请注意，输出内容会根据浏览器的不同而不同。

从错误处理中可以看到，错误来自于异步代码的setTimeout( )功能。

结论

在进行错误处理时，不要隐藏问题，而应该及时发现问题，并采用各种方法追溯问题的根源以便解决问题。虽然编写代码时，时常难免会埋下错误，但是我们也无须为错误的发生过于感到羞愧，及时解决发现问题从而避免更大的问题发生，正是我们现在需要做的。

总结

Das obige ist der detaillierte Inhalt vonZusammenfassung der korrekten Fehlerbehandlung in JavaScript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!