Zusammenfassung der von JS ausgelösten Verwendungsfehler

Dieses Mal werde ich Ihnen eine Zusammenfassung der Verwendung von JS-Wurffehlern und der Vorsichtsmaßnahmen für JS-Wurffehler geben. Hier sind tatsächliche Fälle, werfen wir einen Blick darauf.

Fehler in JS zu werfen ist eine Kunst. Es braucht Zeit, um herauszufinden, an welcher Stelle in Ihrem Code ein Fehler ausgegeben werden sollte. Sobald Sie dies herausgefunden haben, wird die Zeit, die Sie für das Debuggen Ihres Codes benötigen, viel kürzer sein und Ihre Zufriedenheit mit Ihrem Code wird erheblich steigen.

Die Natur des Fehlers

Ein Programm löst einen Fehler aus, wenn etwas Unerwartetes passiert. Möglicherweise wurde einer Funktion ein falscher Wert übergeben oder eine mathematische Operation hat einen ungültigen Operanden festgestellt. Programmiersprachen definieren einen grundlegenden Regelsatz, Abweichungen von diesen Regeln führen zu Fehlern und Entwickler können dann den Code korrigieren. Das Debuggen ist sehr schwierig, wenn Ihnen keine Fehler gemeldet oder gemeldet werden. Wenn alle Fehler stumm bleiben, besteht das erste Problem darin, dass es viel Zeit in Anspruch nimmt, sie zu finden, geschweige denn, sie zu isolieren und zu beheben. Daher sind Fehler der Freund eines Entwicklers, nicht sein Feind.

Fehler tauchen oft an unerwarteten Orten und zu unpassenden Zeiten auf, was sehr problematisch ist. Schlimmer noch: Die Standardfehlermeldungen sind oft zu kurz, um zu erklären, was genau schief gelaufen ist. JS-Fehlermeldungen sind dafür bekannt, spärlich und kryptisch zu sein (insbesondere in älteren IE-Versionen), was das Problem nur verschlimmert. Stellen Sie sich vor, es würde eine Fehlermeldung angezeigt werden, die besagt: „Dieser Funktionsaufruf ist fehlgeschlagen, weil diese Bedingungen aufgetreten sind.“ Dann wird die Debugging-Aufgabe sofort einfacher, was den Vorteil bietet, dass Sie Ihre eigenen Fehler auslösen können.

Es ist sehr hilfreich, sich Fehler als eingebaute Fehlerfälle vorzustellen. Es ist viel einfacher, einen Fehler an einer bestimmten Stelle in Ihrem Code einzuplanen, als überall mit einem Fehler zu rechnen. Dies ist eine sehr gängige Praxis im Produktdesign, nicht nur beim Codieren. Autos verfügen außerdem über stoßabsorbierende Bereiche, in denen der Rahmen so konstruiert ist, dass er bei einem Aufprall auf vorhersehbare Weise zusammenbricht. Wenn die Hersteller wissen, wie diese Rahmen bei einem Unfall reagieren – insbesondere welche Teile versagen –, können sie die Sicherheit der Passagiere gewährleisten. Auch Ihr Code kann auf diese Weise erstellt werden.

Fehler in JS auslösen

Es besteht kein Zweifel daran, dass das Auslösen von Fehlern in JS wertvoller ist, als dasselbe in jeder anderen Sprache zu tun, und das liegt an den Nachteilen des webseitigen Debuggens Komplexität. Mit dem Throw-Operator können Sie ein bereitgestelltes Objekt als Fehler auslösen. Objekte jeglicher Art können als Fehler ausgegeben werden, am häufigsten werden jedoch Fehlerobjekte verwendet.

throw new Error('Something bad happened.');

Der eingebaute Fehlertyp ist in allen JS-Implementierungen gültig. Sein Konstruktor akzeptiert nur einen Parameter, der sich auf die Fehlermeldung bezieht. Wenn auf diese Weise ein Fehler ausgelöst wird, zeigt der Browser die Nachricht (Nachrichtenzeichenfolge) normalerweise direkt an, sofern sie nicht von einer Try-Catch-Anweisung abgefangen wird. Die meisten Browser verfügen heute über eine Konsole, in der Fehlermeldungen ausgegeben werden, sobald ein Fehler auftritt. Mit anderen Worten: Alle Fehler, die Sie auslösen, und diejenigen, die Sie nicht auslösen, werden auf die gleiche Weise behandelt.

Unerfahrene Entwickler geben manchmal direkt eine Zeichenfolge als Fehler aus, wie zum Beispiel:

// 不好的写法throw 'message';

Dies löst zwar einen Fehler aus, aber nicht alle Browser reagieren. Alles wird so sein, wie Sie es erwartet haben. Firefox, Opera und Chrome zeigen alle eine Meldung „nicht erfasste Ausnahme“ an und enthalten die obige Meldungszeichenfolge. Safari und IE geben einfach den Fehler „nicht abgefangene Ausnahme“ aus, ohne die obige Meldungszeichenfolge bereitzustellen, was für das Debuggen nicht hilfreich ist.

Natürlich können Sie jede Art von Daten werfen, wenn Sie möchten. Es gibt keine Regelbeschränkung, die kein bestimmter Datentyp sein kann.

throw { name: 'Nicholas' };throw true;throw 12345;throw new Date();

Beachten Sie, dass jeder ausgegebene Wert einen Fehler auslöst, wenn er nicht durch eine Try-Catch-Anweisung erfasst wird. Firefox, Opera und Chrome rufen alle die String()-Funktion für den ausgegebenen Wert auf, um die Anzeigelogik der Fehlermeldung zu vervollständigen. Dies ist jedoch bei Safari und IE nicht der Fall. Für alle Browser besteht die einzige fehlerfreie Möglichkeit, eine benutzerdefinierte Fehlermeldung anzuzeigen, in der Verwendung eines Error-Objekts.

Vorteile des Auslösens von Fehlern

Durch das Auslösen eigener Fehler können Sie den genauen Text verwenden, der im Browser angezeigt wird. Zusätzlich zu den Zeilen- und Spaltennummern können Sie alle Informationen angeben, die Sie zum Debuggen des Problems benötigen. Ich empfehle, in der Fehlermeldung immer den Funktionsnamen sowie den Grund anzugeben, warum die Funktion fehlgeschlagen ist. Untersuchen Sie die folgende Funktion:

function getDivs (element) {  return element.getElementsByTagName('div');
}

Diese Funktion dient dazu, die div-Elemente aller untergeordneten Elemente unter dem Elementelement abzurufen. Es mag üblich sein, einen Nullwert an ein DOM-Element zu übergeben, das dann an eine Funktion zur Bearbeitung übergeben wird, aber was tatsächlich benötigt wird, ist ein DOM-Element. Was passiert, wenn Sie dieser Funktion null übergeben? Es wird eine vage Fehlermeldung ähnlich der Meldung „Objekt erwartet“ angezeigt. Anschließend müssen Sie sich den Ausführungsstapel ansehen und das Problem tatsächlich in der Quelldatei lokalisieren. Das Debuggen ist einfacher, indem ein Fehler ausgegeben wird:

function getDivs (element) {  if (element && element.getElementsByTagName) {    return element.getElementsByTagName('div');
  } else {    throw new Error('getDivs(): Argument must be a DOM element.');
  }
}

现在给getDivs()函数抛出一个错误，任何时候只要element不满足继续执行的条件，就会抛出一个错误明确地陈述发生的问题。如果在浏览器控制台中输出该错误，你马上能开始调试，并知道最有可能导致该错误的原因是调用函数试图用一个值为null的DOM元素去做进一步的事情。

我倾向于认为抛出错误就像给自己留下告诉自己为什么失败的标签。

何时抛出错误

理解了如何抛出错误只是等式的一个部分，另外一部分就是要理解什么时候抛出错误。由于JS没有类型和参数检查，大量的开发者错误地假设他们自己应该实现每个函数的类型检查。这种做法并不实际，并且会对脚本的整体性能造成影响。考察下面的函数，它试图实现充分的类型检查。

// 不好的做法：检查了太多的错误function addClass (element, className) {  if (!element || typeof element.className !== 'string') {    throw new Error('addClass(): First argument must be a DOM element.');
  }  if (typeof className !== 'string') {    throw new Error('addClass(): Second argument must be a string.');
  }
  element.className += '' + className;
}

这个函数本来只是简单地给一个给定的元素增加一个CSS类名（className），因此，函数的大部分工作变成了错误检查。纵然它能在每个函数中检查每个参数（模仿静态语言），在JS中这么做也会引起过度的杀伤。辨识代码中哪些部分在特定的情况下最有可能导致失败，并只在那些地方抛出错误才是关键所在。

在上例中，最有可能引发错误的是给函数传递一个null引用值。如果第二个参数是null或者一个数字或者一个布尔值是不会抛出错误的，因为JS会将其强制转换为字符串。那意味着导致DOM元素的显示不符合期望，但这并不至于提高到严重错误的程度。所以，我只会检查DOM元素。

// 好的写法function addClass (element, className) {  if (!element || typeof element.className !== 'string') {    throw new Error('addClass(): First argument must be a DOM element.');
  }
  element.className += '' + className;
}

如果一个函数只被已知的实体调用，错误检查很可能没有必要（这个案例是私有函数）；如果不能提前确定函数会被调用的所有地方，你很可能需要一些错误检查。这就更有可能从抛出自己的错误中获益。抛出错误最佳的地方是在工具函数中，如addClass()函数，它是通用脚本环境中的一部分，会在很多地方使用，更准确的案例是JS类库。

针对已知条件引发的错误，所有的JS类库都应该从它们的公共接口里抛出错误。如jQuery、YUI和Dojo等大型的库，不可能预料你在何时何地调用了它们的函数。当你做错事的时候通知你是它们的责任，因为你不可能进入库代码中去调试错误的原因。函数调用栈应该在进入库代码接口时就终止，不应该更深了。没有比看到由一打库代码中函数调用时发生一个错误更加糟糕的事情了吧，库的开发者应该承担起防止类似情况发生的责任。

私有JS库也类似。许多Web应用程序都有自己专用的内置的JS库或“拿来”一些有名的开源类库（类似jQuery）。类库提供了对脏的实现细节的抽象，目的是让开发者用得更爽。抛出错误有助于对开发者安全地隐藏这些脏的实现细节。

这里有一些关于抛出错误很好的经验法则：

一旦修复了一个很难调试的错误，尝试增加一两个自定义错误。当再次发生错误时，这将有助于更容易地解决问题。

如果正在编写代码，思考一下：“我希望[某些事情]不会发生，如果发生，我的代码会一团糟糕”。这时，如果“某些事情”发生，就抛出一个错误。

如果正在编写的代码别人（不知道是谁）也会使用，思考一下他们使用的方式，在特定的情况下抛出错误。

请牢记，我们目的不是防止错误，而是在错误发生时能更加容易地调试。

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

推荐阅读：

jscss基础操作总结

为什么web开发中需要避免使用全局变量

Das obige ist der detaillierte Inhalt vonZusammenfassung der von JS ausgelösten Verwendungsfehler. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!