Detaillierte Erklärung der JavaScript-Fehlererfassung

1. Grundlegende Verwendung und Logik

verwenden

versuchen{
    //Code....
}fang(fehler){
    //Fehlerbehandlung
}Endlich{
    //egal was beim Try/Catch passiert (Fehler oder kein Fehler), dieser Code in der Finally-Anweisung sollte ausgeführt werden. 
}

Logik

2. Funktionen

try...catch funktioniert nur bei Laufzeitfehlern, bei Interpreterfehlern funktioniert es nicht richtig

versuchen{
    {{{{{{{
}fang(fehler){
    console.error(fehler)
}
// Der Engine ist beim Parsen ein Fehler unterlaufen, der sie daran hinderte, den Code zu verstehen und ihn somit abzufangen.

try...catch funktioniert nur synchron

versuchen{
    setzeTimeout(Funktion(){
        undefinierte Variable;
    },1000)
}fang(fehler){
    console.error(fehler)
}
//Wenn die Callback-Funktion von setTimeout ausgeführt wird, hat die Engine die try...catch-Struktur verlassen

Schließlich kann die Return-Anweisung im Try-Block ungültig gemacht werden

Funktionstest () {
  versuchen {
    Rückgabe 1;
  } fange(Fehler) {
    Rückgabe 2;
  Endlich
    Rückgabe 3;
  }
}
Konsole.log(Test());
//3

3. Fehlerobjekt

Wenn im Programm ein Fehler auftritt, wird in js ein Objekt mit den Fehlerdetails generiert und das Objekt als Parameter an den Catch übergeben.

Wie alle eingebauten Fehler hat das Fehlerobjekt zwei Haupteigenschaften

• Name Fehlertyp
• Nachrichtentexttyp Fehlermeldung
• Stapel (nicht standardmäßiges Attribut) Rufen Sie Stapelinformationen auf, wenn ein Fehler auftritt, hauptsächlich zum Debuggen verwendet

versuchen {
  lalala; // Fehler, Variable ist nicht definiert!
} fangen (Fehler) {
  alert(err.name); // Referenzfehler
  alert(err.message); // lalala ist nicht definiert
  alert(err.stack); // Referenzfehler: lalala ist bei (...Aufrufstapel) nicht definiert

  // Kann auch einen Fehler als Ganzes anzeigen
  // Der Fehler wird in eine Zeichenfolge als „Name: Nachricht“ umgewandelt.
  alert(err); // ReferenceError: lalala ist nicht definiert
}

Theoretisch können wir alles als Fehlerobjekt werfen, die beste Vorgehensweise besteht jedoch darin, ein Objekt mit einem Namen und einer Nachricht zu werfen, um die Kompatibilität mit dem integrierten Fehlerobjekt zu wahren.

Extra: Eingebautes Fehlerobjekt

4. Bessere Fang- und Wurfstrategien

​ Fehler zu erfassen dient nicht nur dazu, Programmabstürze zu verhindern, sondern vor allem dazu, das Debuggen zu erleichtern und Fehler zu finden. Daher kann die Fehlerbehandlungsstrategie leicht die Eleganz des Programmierers widerspiegeln.

Wie das Sprichwort sagt, sind Programmierer immer elegant. Versuchen Sie, einem Prinzip zu folgen: Fangen Sie nur die Fehler ab, von denen Sie wissen.

Halte eine Birne hoch

let json = '{ "Alter": 30 }'; 
versuchen{
  let Benutzer = JSON.parse(json);  
  Alarm (Benutzername);
} fangen (Fehler) {
  console.error('JSON-Fehler:'+err);
}

Die Catch-Strategie im obigen Beispiel kann den normalen Betrieb des Programms sicherstellen, da der Catch-Block alle darin enthaltenen Fehler abfangen kann, egal ob es sich um einen Fehler in JSON.parse oder einen Fehler in user.name not exists handelt, beide können abgefangen werden. Das Drucken beider Fehler auf dieselbe Weise ist jedoch nicht förderlich für das Debuggen. Es wäre besser, es wie folgt zu schreiben

let json = '{"Alter":30}'
versuchen{
  let Benutzer = JSON.parse(json);
  Alarm(Benutzername)
}fang(fehler){
   if (err Instanz von SyntaxError) {
       console.error('JSON-Fehler:'+err);
   }
   sonst werfe er;
}

Jeder Catch-Block behandelt die Fehler, von denen er weiß, dass sie auftreten können. Das heißt, beim Programmieren fangen Programmierer die erwarteten Fehler ab und verwerfen die Fehler, mit denen sie möglicherweise nicht gerechnet haben.

5. Promise-Fehlerbehandlung

Wie wir alle wissen, schluckt Promise Fehler, da die Implementierung von Promise alle Fehler intern erfasst und die erfassten Fehler nicht nach außen (außerhalb von Promise) ausgegeben, sondern durch Suchen des nächstgelegenen Onreject-Rückrufs entlang der Kette weitergeleitet werden. Daher gibt es nur zwei Möglichkeiten, mit Promise-Fehlern umzugehen:

1. Festlegen des Onreject-Rückrufs
2. Globale Erfassung
   

Zum Beispiel

versuchen{
    neues Versprechen((lösen,ablehnen)=>{
        wirf einen neuen Fehler (,,Versprechensfehler‘‘)
    }).fangen(()=>{
        //Der Fehler wurde im letzten Onreject-Callback abgefangen console.error(err);
    })
}fang(fehler){
    //Nie ausgeführt, Versprechen verschluckt Fehler
    Konsole.Fehler(Fehler);
}

Beachten Sie auch, dass unabhängig von der Executor-Funktion oder dem Promise-Handler alle darin auftretenden Fehler geschluckt werden, was gleichbedeutend damit ist, implizit abgefangen zu werden. Der Fehler findet automatisch den nächstgelegenen Onreject-Callback und übergibt ihn.

versuchen{
    neues Versprechen((lösen,ablehnen)=>{
        lösen();
    }).dann(()=>{
        neuen Fehler werfen ('Versprechen, dann Fehler');
    }).catch((err){
        Konsole.Fehler(Fehler);
    })
}fang(fehler){
    //console.error(err) wird nicht ausgeführt, bis die Erde zerstört ist
}

Ebenso sind alle bis dahin registrierten onfulfilled-Rückrufe ungültig, bevor der Fehler gefunden und an onreject übergeben wird, bis der onreject-Rückruf gefunden und verarbeitet wird. Der onfulfilled-Rückruf nach dem onreject-Rückruf ist normal.

versuchen {
    neues Versprechen((lösen, ablehnen) => {
        wirf einen neuen Fehler (,,Versprechensfehler‘‘)
    }).then((ret) => {
        //Der Fehler wird nicht behandelt und es schlägt fehl console.log('then1:' + ret)
    }).catch((err) => {
        //Der Fehler wird behandelt, die nachfolgende Sequenz ist normal console.error(err);
        Rückgabe 'bearbeitet'
    }).then((ret) => {
        //Normale Ausführung console.log('then2' + ret);
    })
} fangen (Fehler) {
    //Ebenso wird console.error(err) nicht ausgeführt, bis die Menschheit zerstört ist
}

// Fehler: Promise-Fehler
//dann2behandelt

Was passiert, wenn in der gesamten Kette kein Catch-Set vorhanden ist?

Dann dringt dieser Fehler vom Erdmittelpunkt bis in die globale Umgebung vor und löst je nach Hostumgebung unterschiedliche globale Ereignisse aus. Beispielsweise wird das Ereignis „unhandledrejection“ im Browser ausgelöst, und das Ereignis „unhandledRejection“ wird auch in der Knotenumgebung ausgelöst. Im Allgemeinen wird dieses Ereignis überwacht und die Informationen werden dann dem Programmierer oder Benutzer angezeigt.

Extra 1: Promise interne Fehlererfassung von Chromium / V8 / V8 / 3.29.45

Extra 2: asynchrone/wartende Fehlererfassung

6. Leistungsverlust

Ab V8 Version 6 (ausgeliefert mit Node 8.3 und dem neuesten Chrome) ist die Leistung von Code innerhalb von Try-Catch dieselbe wie die von normalem Code. ------ Zurück zur Übersicht

(Ich habe es ein wenig getestet und der Unterschied ist nicht groß)

Oben finden Sie eine ausführliche Erläuterung zur JavaScript-Fehlererfassung. Weitere Informationen zur JavaScript-Fehlererfassung finden Sie in den anderen verwandten Artikeln auf 123WORDPRESS.COM!