sprawdzanie typu błędu w JS

W JS nie wydaje się możliwe sprawdzenie, czy argument przekazany do funkcji jest rzeczywiście typu „błąd”, czy też wystąpieniem błędu.

Na przykład to nie jest prawidłowe:

typeof err === 'error'

ponieważ istnieje tylko 6 możliwych typów (w postaci ciągów):

Operator typeof zwraca informacje o typie w postaci ciągu. Istnieje sześć możliwych wartości, które typeofzwracają:

„liczba”, „ciąg znaków”, „wartość logiczna”, „obiekt”, „funkcja” i „nieokreślona”.

MSDN

Ale co, jeśli mam taki prosty przypadek użycia:

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);
    }
}

więc jaki jest najlepszy sposób określenia, czy argument jest wystąpieniem błędu?

czy instanceofoperator ma jakąś pomoc?

Możesz użyć instanceofoperatora (ale zobacz zastrzeżenie poniżej!).

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

Powyższe nie zadziała, jeśli błąd został zgłoszony w innym oknie / ramce / ramce iframe niż ta, w której odbywa się sprawdzanie. W takim przypadku instanceof Errorsprawdzenie zwróci fałsz, nawet dla Errorobiektu. W takim przypadku najłatwiejszym podejściem jest pisanie na klawiaturze.

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

Jednak pisanie typu kaczego może generować fałszywe alarmy, jeśli masz obiekty bez błędów, które zawierają stacki messagewłaściwości.

Zadałem oryginalne pytanie - odpowiedź @ Trott jest z pewnością najlepsza.

Jednak ze względu na to, że JS jest językiem dynamicznym i jest tak wiele środowisk wykonawczych JS, instanceofoperator może zawieść, szczególnie w przypadku programowania front-end, gdy przekracza granice, takie jak ramki iframe. Zobacz: https://github.com/mrdoob/three.js/issues/5886

Jeśli nie przeszkadza ci pisanie kaczkami, to powinno być dobre:

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

Osobiście wolę języki statyczne, ale jeśli używasz języka dynamicznego, najlepiej jest objąć język dynamiczny takim, jakim jest, zamiast zmuszać go do zachowywania się jak język z typowaniem statycznym.

jeśli chcesz uzyskać dokładniejsze informacje, możesz zrobić to:

   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

Jedyny problem z tym jest

myError instanceof Object // true

Alternatywą byłoby użycie właściwości constructor.

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

Chociaż należy zauważyć, że to dopasowanie jest bardzo specyficzne, na przykład:

myError.constructor === TypeError // false

Możesz użyć, Object.prototype.toStringaby łatwo sprawdzić, czy obiekt jest Error, który będzie działał również dla różnych ramek.

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([]));

Możesz użyć obj.constructor.name, aby sprawdzić „klasę” obiektu https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#Function_names_in_classes

Na przykład

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

Powyższa linia zarejestruje „Błąd”, który jest nazwą klasy obiektu. Można tego użyć z dowolnymi klasami w javascript, jeśli klasa nie używa właściwości o nazwie „nazwa”

Dzięki @Trott za twój kod, właśnie użyłem tego samego kodu i dodałem przykład pracy w czasie rzeczywistym dla dobra innych.

<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>

Lub użyj tego do różnych typów błędów

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