javascript exception - Was ist der Unterschied zwischen `new error` und` throw someObject`?




handling best (5)

Sie erwähnen zuerst diesen Code:

throw new Error('sample')

und dann schreibst du in deinem ersten Beispiel:

throw new Error({'hehe':'haha'}) 

Das erste Error-Objekt würde tatsächlich funktionieren, weil es einen String-Wert erwartet, in diesem Fall 'sample'. Die zweite würde nicht, weil Sie versuchen, ein Objekt zu übergeben, und es erwartet eine Zeichenfolge.

Das Fehlerobjekt würde die "message" -Eigenschaft haben, was "sample" wäre.

Ich möchte einen allgemeinen Fehlerhandler schreiben, der benutzerdefinierte Fehler abfangen kann, die bei jeder Instanz des Codes absichtlich geworfen werden.

Wenn ich throw new Error('sample') wie im folgenden Code throw new Error('sample')

try {
    throw new Error({'hehe':'haha'});
    // throw new Error('hehe');
} catch(e) {
    alert(e);
    console.log(e);
}

Log erscheint in Firefox als Error: [object Object] und ich konnte das Objekt nicht analysieren.

Für den zweiten throw zeigt das Log als: Error: hehe

Während ich es tat

try {
    throw ({'hehe':'haha'});
} catch(e) {
    alert(e);
    console.log(e);
}

Die Konsole zeigte als: Object { hehe="haha"} in dem ich auf die Fehlereigenschaften zugreifen konnte.

Was ist der Unterschied?

Ist der Unterschied im Code zu sehen? Wie String wird nur als String und Objekt als Objekte übergeben, aber die Syntax wird anders sein?

Ich habe kein Wurffehlerobjekt erforscht ... Ich hatte nur Saiten geworfen.

Gibt es einen anderen Weg als die oben genannten zwei Methoden?


werfe "Ich bin böse"

Throw wird die weitere Ausführung beenden und die Nachrichtenzeichenfolge anzeigen, wenn der Fehler auftritt.

try{
    throw 'I\'m Evil'
    console.log('You\'ll never reach to me', 123465)
}
catch(e){
    console.log(e); //I\'m Evil
}

"Console after throw" wird niemals wegen der Kündigung erreicht.

neuen Fehler werfen ("Ich bin so süß")

throw new Error legt ein Fehlerereignis mit zwei Parametern name und message offen. Es beendet auch die weitere Ausführung

try{
     throw new Error('I\'m Evil')
     console.log('You\'ll never reach to me', 123465)
}
catch(e){
        console.log(e.name, e.message); //Error, I\'m Evil
}

Hier ist eine gute Erklärung über das Fehler-Objekt und das Werfen eigener Fehler

Das Fehlerobjekt

genau das, was wir im Falle eines Fehlers daraus gewinnen können. Das Fehlerobjekt in allen Browsern unterstützt die folgenden zwei Eigenschaften:

  • name: Der Name des Fehlers oder genauer der Name der Konstruktorfunktion, zu der der Fehler gehört.

  • Nachricht: Eine Beschreibung des Fehlers, wobei diese Beschreibung vom Browser abhängt.

Sechs mögliche Werte können von der Eigenschaft name zurückgegeben werden, die wie erwähnt den Namen der Konstruktoren des Fehlers entspricht. Sie sind:

Error Name          Description

EvalError           An error in the eval() function has occurred.

RangeError          Out of range number value has occurred.

ReferenceError      An illegal reference has occurred.

SyntaxError         A syntax error within code inside the eval() function has occurred.
                    All other syntax errors are not caught by try/catch/finally, and will
                    trigger the default browser error message associated with the error. 
                    To catch actual syntax errors, you may use the onerror event.

TypeError           An error in the expected variable type has occurred.

URIError            An error when encoding or decoding the URI has occurred 
                   (ie: when calling encodeURI()).

Eigene Fehler werfen (Ausnahmen)

Anstatt zu warten, bis einer der 6 Fehlertypen auftritt, bevor die Steuerung automatisch vom try-Block in den catch-Block übertragen wird, können Sie auch explizit eigene Ausnahmen auslösen, um dies bei Bedarf zu erzwingen. Dies ist ideal, um eigene Definitionen dafür zu erstellen, was ein Fehler ist und wann die Kontrolle übertragen werden sollte.


Der folgende Artikel geht vielleicht genauer darauf ein, welche die bessere Wahl ist; throw 'An error' oder throw new Error('An error') :

http://www.nczonline.net/blog/2009/03/10/the-art-of-throwing-javascript-errors-part-2/

Es deutet darauf hin, dass Letzteres ( new Error() ) zuverlässiger ist, da Browser wie Internet Explorer und Safari (Versionen unsicher) die Nachricht nicht korrekt melden, wenn sie den ersten verwenden.

Dadurch wird ein Fehler ausgelöst, aber nicht alle Browser reagieren wie erwartet. Firefox, Opera und Chrome zeigen jeweils eine "nicht abgefangene Ausnahme" -Nachricht an und enthalten dann die Nachrichtenzeichenfolge. Safari und Internet Explorer werfen einfach eine Fehlermeldung "nicht abgefangene Ausnahme" und stellen die Nachrichtenzeichenfolge überhaupt nicht bereit. Dies ist eindeutig vom Gesichtspunkt der Fehlersuche suboptimal.


Sowohl Null als auch undefiniert in JavaScript zeigen an, dass kein Wert vorhanden ist.

var a = null; //variable assigned null value
var b;  // undefined

Trotz der Tatsache, beide existieren für die Abwesenheit von Wert aber: Nicht definiert bedeutet eigentlich, dass die Variable nicht initialisiert wird. Funktionen, die nichts zurückgeben und Funktionsparameter, für die kein Wert angegeben ist, undefinierter Wert wird zurückgegeben. Verwenden Sie strict equality operator ===, um zwischen null und undefined zu unterscheiden.

Referenz: http://www.thesstech.com/javascript/null-and-undefined





javascript object error-handling exception-handling throw