Quero escrever um manipulador de erro comum que capture erros personalizados lançados de propósito em qualquer instância do código.

Quando eu throw new Error('sample')gostei no código a seguir

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

O log é exibido no Firefox Error: [object Object]e eu não consegui analisar o objeto.

Por um segundo, throwo log mostra como:Error: hehe

Considerando que quando eu fiz

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

o console mostrou como: Object { hehe="haha"}no qual eu consegui acessar as propriedades do erro.

Qual é a diferença?

A diferença é vista no código? Como string será apenas passada como string e objeto como objetos, mas a sintaxe será diferente?

Eu não explorei o lançamento do objeto de erro ... eu havia feito apenas o lançamento de strings.

Existe outra maneira além dos dois métodos mencionados acima?

Aqui está uma boa explicação sobre o objeto The Error e lançando seus próprios erros

O objeto de erro

Apenas o que podemos extrair dele em um evento de erro? O objeto Erro em todos os navegadores oferece suporte às duas propriedades a seguir:

• nome: o nome do erro, ou mais especificamente, o nome da função de construtor à qual o erro pertence.

• mensagem: Uma descrição do erro, com essa descrição variando, dependendo do navegador.

Seis valores possíveis podem ser retornados pela propriedade name, que conforme mencionado corresponde aos nomes dos construtores do erro. Eles são:

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()).

Lançando seus próprios erros (exceções)

Em vez de esperar que um dos 6 tipos de erros ocorra antes que o controle seja transferido automaticamente do bloco try para o bloco catch, você também pode lançar explicitamente suas próprias exceções para forçar isso a ocorrer sob demanda. Isso é ótimo para criar suas próprias definições sobre o que é um erro e quando o controle deve ser transferido para captura.

jogue "eu sou mau"

throwirá terminar a posterior execução e expor cadeia de mensagem em captura o erro.

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

O console após o lançamento nunca será alcançado como causa de rescisão.

lançar novo erro ("eu sou tão doce")

throw new Errorexpõe um evento de erro com dois nomes e mensagem de parâmetro . Também encerra a execução adicional

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
}

O artigo a seguir talvez entre em mais detalhes sobre qual é a melhor escolha; throw 'An error'ou throw new Error('An error'):

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

Ele sugere que o último ( new Error()) é mais confiável, pois navegadores como o Internet Explorer e o Safari (sem certeza de versões) não relatam corretamente a mensagem ao usá-lo.

Isso fará com que um erro seja gerado, mas nem todos os navegadores respondem da maneira que você esperaria. Firefox, Opera e Chrome exibem uma mensagem de "exceção não capturada" e incluem a sequência de mensagens. O Safari e o Internet Explorer simplesmente lançam um erro de "exceção não capturada" e não fornecem a sequência da mensagem. Claramente, isso é subótimo do ponto de vista da depuração.

Você primeiro mencionou este código:

throw new Error('sample')

e então no seu primeiro exemplo você escreve:

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

O primeiro objeto Error realmente funcionaria, porque está esperando um valor de string, neste caso 'sample'. O segundo não seria porque você está tentando passar um objeto e espera uma string.

O objeto de erro teria a propriedade "message", que seria 'sample'.

TLDR: eles são equivalentes.

// this:
const x = Error('I was created using a function call!');
​​​​// has the same functionality as this:
const y = new Error('I was constructed via the "new" keyword!');

source: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error

você pode throwcomo objeto

throw ({message: 'This Failed'})

então, por exemplo, no seu try/catch

try {
//
} catch(e) {
    console.log(e); //{message: 'This Failed'}
    console.log(e.message); //This Failed
}

ou apenas lançar um erro de string

throw ('Your error')

try {
//
} catch(e) {
    console.log(e); //Your error
}

throw new Error //only accept a string

O Errorconstrutor é usado para criar um objeto de erro. Os objetos de erro são lançados quando ocorrem erros de tempo de execução. O objeto Erro também pode ser usado como objeto básico para exceções definidas pelo usuário.

Os erros definidos pelo usuário são gerados por meio da throwinstrução o controle do programa será passado para o primeiro catchbloco na pilha de chamadas.

A diferença entre lançar um erro com e sem o objeto Error:

throw {'hehe':'haha'};

No chrome, as devtools são assim:

O Chrome nos diz que temos um erro não detectado, que é apenas um objeto JS. O objeto em si pode ter informações sobre o erro, mas ainda não sabemos imediatamente de onde ele veio. Não é muito útil quando estamos trabalhando em nosso código e depurando-o.

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

No chrome, as devtools são assim:

Um erro lançado com o objeto Error nos fornece um rastreamento de pilha quando o expandimos. Isso nos fornece informações valiosas, de onde veio o erro, que geralmente é informações valiosas ao depurar seu código. Observe também que o erro diz que [object Object]isso ocorre porque o Errorconstrutor espera uma sequência de mensagens como primeiro argumento. Quando recebe um objeto, ele o coage em uma string.

Comportamento de reação

Além do restante das respostas, gostaria de mostrar uma diferença no React.

Se eu jogar ae new Error()estiver no modo de desenvolvimento, receberei uma tela de erro e um log do console. Se eu lançar uma string literal, eu a verei apenas no console e possivelmente a perderá, se não estiver assistindo o log do console.

Exemplo

Lançar um log de erros no console e mostra uma tela de erro enquanto estiver no modo de desenvolvimento (a tela não estará visível na produção).

throw new Error("The application could not authenticate.");

Enquanto o código a seguir apenas efetua login no console:

throw "The application could not authenticate.";