verificando o erro typeof em JS

Em JS, não parece possível verificar se um argumento transmitido para uma função é realmente do tipo 'error' ou uma instância de Error.

Por exemplo, isso não é válido:

typeof err === 'error'

pois existem apenas 6 tipos possíveis (na forma de cadeias):

O operador typeof retorna informações de tipo como uma sequência. Existem seis valores possíveis que typeofretornam:

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

MSDN

Mas e se eu tiver um caso de uso simples como este:

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

então, qual é a melhor maneira de determinar se um argumento é uma instância de Error?

é o instanceofoperador de alguma ajuda?

Você pode usar o instanceofoperador (mas veja a advertência abaixo!).

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

O procedimento acima não funcionará se o erro foi gerado em uma janela / quadro / iframe diferente daquele em que a verificação está ocorrendo. Nesse caso, a instanceof Errorverificação retornará false, mesmo para um Errorobjeto. Nesse caso, a abordagem mais fácil é a digitação de patos.

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

No entanto, pato digitação pode produzir falsos positivos, se você tem objetos não-erro que contêm stacke messagepropriedades.

Eu fiz a pergunta original - a resposta de @ Trott é certamente a melhor.

No entanto, com o JS sendo uma linguagem dinâmica e com muitos ambientes de tempo de execução JS, o instanceofoperador pode falhar, especialmente no desenvolvimento de front-end ao cruzar limites, como iframes. Consulte: https://github.com/mrdoob/three.js/issues/5886

Se você concorda com a digitação do pato, isso deve ser bom:

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

Pessoalmente, prefiro idiomas de tipo estaticamente, mas se você estiver usando um idioma dinâmico, é melhor adotar um idioma dinâmico para o que é, em vez de forçá-lo a se comportar como um idioma de tipo estaticamente.

se você quiser ser um pouco mais preciso, faça o seguinte:

   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

O único problema com isso é

myError instanceof Object // true

Uma alternativa para isso seria usar a propriedade construtor.

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

Embora seja necessário observar que essa correspondência é muito específica, por exemplo:

myError.constructor === TypeError // false

Você pode usar Object.prototype.toStringpara verificar facilmente se um objeto é um Error, o que também funcionará para quadros diferentes.

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

Você pode usar obj.constructor.name para verificar a "classe" de um objeto https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#Function_names_in_classes

Por exemplo

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

A linha acima registrará "Erro", que é o nome da classe do objeto. Isso pode ser usado com qualquer classe em javascript, se a classe não estiver usando uma propriedade com o nome "name"

Obrigado @Trott pelo seu código, usei o mesmo código e adicionei um exemplo de trabalho em tempo real para o benefício de outras pessoas.

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

Ou use-o para diferentes tipos de erros

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