Überprüfung auf Fehlertyp in JS

In JS scheint es nicht möglich zu sein, zu überprüfen, ob ein an eine Funktion übergebenes Argument tatsächlich vom Typ 'error' oder eine Instanz von Error ist.

Dies ist beispielsweise nicht gültig:

typeof err === 'error'

da es nur 6 mögliche Typen gibt (in Form von Strings):

Der Operator typeof gibt Typinformationen als Zeichenfolge zurück. Es gibt sechs mögliche Werte, die typeofzurückgegeben werden:

"number", "string", "boolean", "object", "function" und "undefined".

MSDN

Aber was ist, wenn ich einen einfachen Anwendungsfall wie diesen habe:

function errorHandler(err) {

    if (typeof err === 'error') {
        throw err;
    }
    else {
        console.error('Unexpectedly, no error was passed to error handler. But here is the message:',err);
    }
}

Was ist der beste Weg, um festzustellen, ob ein Argument eine Fehlerinstanz ist?

ist der instanceofBetreiber irgendeine Hilfe?

Sie können den instanceofOperator verwenden (siehe jedoch die Einschränkung unten!).

var myError = new Error('foo');
myError instanceof Error // true
var myString = "Whatever";
myString instanceof Error // false

Das Obige funktioniert nicht, wenn der Fehler in einem anderen Fenster / Frame / Iframe ausgelöst wurde als dort, wo die Überprüfung stattfindet. In diesem Fall gibt die instanceof ErrorPrüfung auch für ein ErrorObjekt false zurück . In diesem Fall ist das Enten-Tippen der einfachste Ansatz.

if (myError && myError.stack && myError.message) {
  // it's an error, probably
}

Allerdings Ente-Eingabe erzeugen kann zu Fehlalarmen kommen, wenn Sie nicht-Fehler - Objekte haben , die enthalten stackund messageEigenschaften.

Ich habe die ursprüngliche Frage gestellt - @ Trotts Antwort ist sicherlich die beste.

Da JS jedoch eine dynamische Sprache ist und es so viele JS-Laufzeitumgebungen gibt, kann der instanceofOperator insbesondere bei der Front-End-Entwicklung fehlschlagen, wenn Grenzen wie Iframes überschritten werden. Siehe: https://github.com/mrdoob/three.js/issues/5886

Wenn Sie mit dem Tippen von Enten einverstanden sind, sollte dies gut sein:

let isError = function(e){
 return e && e.stack && e.message;
}

Ich persönlich bevorzuge statisch typisierte Sprachen, aber wenn Sie eine dynamische Sprache verwenden, ist es am besten, eine dynamische Sprache als das zu akzeptieren, was sie ist, anstatt sie zu zwingen, sich wie eine statisch typisierte Sprache zu verhalten.

Wenn Sie etwas genauer werden möchten, können Sie dies tun:

   let isError = function(e){
     return e && e.stack && e.message && typeof e.stack === 'string' 
            && typeof e.message === 'string';
    }

var myError = new Error('foo');
myError instanceof Error // true
var myString = "Whatever";
myString instanceof Error // false

Das einzige Problem dabei ist

myError instanceof Object // true

Eine Alternative dazu wäre die Verwendung der Konstruktoreigenschaft.

myError.constructor === Object // false
myError.constructor === String // false
myError.constructor === Boolean // false
myError.constructor === Symbol // false
myError.constructor === Function // false
myError.constructor === Error // true

Obwohl zu beachten ist, dass diese Übereinstimmung sehr spezifisch ist, zum Beispiel:

myError.constructor === TypeError // false

Sie können Object.prototype.toStringdamit leicht überprüfen, ob es sich bei einem Objekt um ein Objekt handelt Error, das auch für verschiedene Frames funktioniert.

function isError(obj){
    return Object.prototype.toString.call(obj) === "[object Error]";
}

function isError(obj){
    return Object.prototype.toString.call(obj) === "[object Error]";
}
console.log("Error:", isError(new Error));
console.log("RangeError:", isError(new RangeError));
console.log("SyntaxError:", isError(new SyntaxError));
console.log("Object:", isError({}));
console.log("Array:", isError([]));

Mit obj.constructor.name können Sie die "Klasse" eines Objekts https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#Function_names_in_classes überprüfen

Beispielsweise

var error = new Error("ValidationError");
console.log(error.constructor.name);

In der obigen Zeile wird "Fehler" protokolliert, der der Klassenname des Objekts ist. Dies kann mit allen Klassen in Javascript verwendet werden, wenn die Klasse keine Eigenschaft verwendet, die den Namen "name" trägt.

Vielen Dank an @Trott für Ihren Code. Ich habe nur denselben Code verwendet und ein Echtzeit-Arbeitsbeispiel zum Nutzen anderer hinzugefügt.

<html>
<body >

<p>The **instanceof** operator returns true if the specified object is an instance of the specified object.</p>



<script>
	var myError = new Error("TypeError: Cannot set property 'innerHTML' of null"); // error type when element is not defined
	myError instanceof Error // true
	
	
	
	
	function test(){
	
	var v1 = document.getElementById("myid").innerHTML ="zunu"; // to change with this
	
	try {
		  var v1 = document.getElementById("myidd").innerHTML ="zunu"; // exception caught
		  } 
		  
	catch (e) {
		  if (e instanceof Error) {
			console.error(e.name + ': ' + e.message) // error will be displayed at browser console
		  }
  }
  finally{
		var v1 = document.getElementById("myid").innerHTML ="Text Changed to Zunu"; // finally innerHTML changed to this.
	}
	
	}
	
</script>
<p id="myid">This text will change</p>
<input type="button" onclick="test();">
</body>
</html>

Oder verwenden Sie dies für verschiedene Arten von Fehlern

function isError(val) {
  return (!!val && typeof val === 'object')
    && ((Object.prototype.toString.call(val) === '[object Error]')
      || (typeof val.message === 'string' && typeof val.name === 'string'))
}