Quais são as práticas recomendadas para o tratamento de erros de JavaScript?

Eu estou olhando para começar a fazer o meu JavaScript um pouco mais à prova de erro, e estou encontrando muita documentação sobre o uso try, catch, finally, e throw, mas eu não estou encontrando uma tonelada de conselhos de especialistas sobre quando e onde jogar erros.

• Todo código deve ser envolvido em uma tentativa / captura?
• Há mais conselhos como esse em que ponto os erros devem ser detectados?
• Existem desvantagens em gerar erros, em vez de o código falhar silenciosamente na produção?
• Isso foi abordado no SO em relação às implementações, mas os erros de JS do log do servidor são uma estratégia eficaz?
• Mais alguma coisa que eu deveria saber sobre erros de interceptação no meu aplicativo?

Também sou um jogo completo para ouvir livros que têm ótimos capítulos ou explicações detalhadas sobre como lidar com erros. O JavaScript eloquente aborda o assunto, mas não é muito prescritivo ou opinativo sobre o assunto.

Agradeço qualquer conselho que você possa dar!

Um conjunto imensamente interessante de slides no Enterprise JavaScript Error Handling pode ser encontrado em http://www.devhands.com/2008/10/javascript-error-handling-and-general-best-practices/

Em resumo, resume:

1. Suponha que seu código falhe
2. Erros de log no servidor
3. Você, não o navegador, lida com erros
4. Identifique onde os erros podem ocorrer
5. Jogue seus próprios erros
6. Distinguir erros fatais versus erros não fatais
7. Fornecer um modo de depuração

Os slides entram em muito mais detalhes e provavelmente darão alguma orientação.

ATUALIZAR

A apresentação mencionada acima pode ser encontrada aqui: http://www.slideshare.net/nzakas/enterprise-javascript-error-handling-presentation

Nicholas Zakas, do Yahoo! fama fez uma palestra sobre Manipulação de Erros Corporativos ( slides ) no Ajax Experience 2008, na qual ele propôs algo assim:

function log(sev,msg) {
    var img = new Image();
    img.src = "log.php?sev=" +
        encodeURIComponent(sev) +
        "&msg=" + encodeURIComponent(msg);
}

// usage
log(1, "Something bad happened.")

// Auto-log uncaught JS errors
window.onerror = function(msg, url, line) {
    log(1, msg);
    return true;
}

Um ano depois, Nicholas Zakas postou uma atualização em seu blog, que incluía um padrão inteligente para injetar código de tratamento de erros automaticamente em seu ambiente de produção (usando programação orientada a aspectos).

Quando você começa a registrar as chamadas window.error, notará duas coisas:

1. Se o seu site for bastante complexo, você registrará muitos erros
2. Você verá várias mensagens "window.error" inúteis em undefined: 0 "

Reduzir o torrent de entradas de log é tão simples quanto testar a gravidade e / ou um número aleatório antes de efetuar o logon no servidor:

function log(sev,msg) {
    if (Math.random() > 0.1) return; // only log some errors

    var img = new Image();
    img.src = "log.php?sev=" +
        encodeURIComponent(sev) +
        "&msg=" + encodeURIComponent(msg);
}

O tratamento dos erros inúteis "window.error em undefined: 0" depende da arquitetura do site, mas pode tentar identificar todas as chamadas do Ajax e gerar uma exceção quando algo falhar (possivelmente retornando um rastreamento de pilha usando o stacktrace.js ).

IHMO, você deve usar o tratamento de erros em javascript como em várias outras línguas (AFAIK: Python, Java).

Para melhor legibilidade (e provavelmente melhor desempenho, mesmo que eu não tenha certeza de que tenha um impacto muito grande), você deve usar o bloco try / catch principalmente nos seguintes casos:

• A parte do código que você deseja quebrar é uma parte essencial de todo o algoritmo . Se falhar, poderá:

  • crie erros na próxima parte dos códigos (por exemplo, porque um var está ausente ...)
  • faça com que a página não tenha a aparência esperada (impacto no conteúdo ou no css)
  • fazer com que os resultados pareçam estranhos para o usuário (impacto no comportamento do código)

• Você sabe que o código que está escrevendo não é compatível com todos os navegadores

• Você planejou que o código falhe (porque não há outra maneira de verificar se ele deve funcionar se ... então ... bloqueia)
• E também quando você deseja depurar sem incomodar o usuário final

Eventualmente, os especialistas em javascript podem ter outros elementos para fornecer.

meus 2 centavos para a caixa,

Saudações,

Máx.

Além das outras respostas: uma coisa importante é usar os dados de contexto disponíveis nos objetos de erro do JavaScript e nos window.onerrorparâmetros da função.

Coisas como o rastreamento de pilha (errorObject.stack), o nome do arquivo, o número da linha e o número da coluna. Observe que cada navegador tem algumas diferenças ... então faça o seu melhor para obter bons erros.

Pode até haver problemas com o próprio objeto do console . Eu uso uma função window.onerror personalizada inspirada neste e uma função especial para rastrear qualquer objeto de erro padrão inspirado nesse código .

Outro ponto positivo é incluir a versão do seu aplicativo da Web em algum lugar próximo ao rastreamento de pilha (para copiar e colar de maneira rápida e segura). Você também pode mostrar erros de forma mais agressiva (alerta ...) no modo de desenvolvimento, pois os desenvolvedores não monitoram constantemente o console do navegador e podem não ver alguns dos problemas.

Além disso, use evitar usar throw 'My message', usar throw new Error('My message'), você pode até ter erros personalizados, leia este artigo .

Sempre adicione algum contexto aos erros (a versão, o ID do objeto, alguma mensagem personalizada ...) e também faça uma distinção entre erros externos (alguns dados ou circunstâncias externas causaram falha no sistema) e erros internos / assertions (seu próprio sistema está estragado), leia sobre ' Design by contract '.

Aqui está um guia .

Pense também em usar o tratamento geral de erros, como interceptadores de suas bibliotecas e estruturas:

• jQuery
• 1.x angular e para http
• Angular 2.x
• Seu novo quadro de drogas aqui ...