---
title: "Para onde vai o erro"
url: "https://www.mikefluff.com/pt/experiments/js-ch10-lost-error"
locale: "pt"
author: "Mikhail Savchenko (Mike Fluff)"
updated: "2026-11-18"
description: "Rejeições de promise não tratadas e try/catch em código assíncrono"
book: "https://www.mikefluff.com/pt/books/from-closures-to-autonomous-systems"
alternates:
  - locale: "en"
    url: "https://www.mikefluff.com/en/experiments/js-ch10-lost-error"
    markdown: "https://www.mikefluff.com/en/experiments/js-ch10-lost-error.md"
  - locale: "ru"
    url: "https://www.mikefluff.com/ru/experiments/js-ch10-lost-error"
    markdown: "https://www.mikefluff.com/ru/experiments/js-ch10-lost-error.md"
  - locale: "pt"
    url: "https://www.mikefluff.com/pt/experiments/js-ch10-lost-error"
    markdown: "https://www.mikefluff.com/pt/experiments/js-ch10-lost-error.md"
  - locale: "es"
    url: "https://www.mikefluff.com/es/experiments/js-ch10-lost-error"
    markdown: "https://www.mikefluff.com/es/experiments/js-ch10-lost-error.md"
---

# Para onde vai o erro

*Rejeições de promise não tratadas e try/catch em código assíncrono*

## O que é uma unhandled promise rejection?

Uma unhandled promise rejection, ou rejeição de promise não tratada, acontece quando uma promise é rejeitada e não há nada para tratá-la: nem .catch, nem segundo argumento no .then, nem await dentro de um try. No navegador o window recebe o evento unhandledrejection e a página segue funcionando. O Node é mais rígido. Desde a versão 15 o padrão é encerrar o processo com erro, e o resto do programa não roda. A cura é dar a cada promise alguém que espere pelo resultado dela.

Um try/catch comum pega os erros lançados enquanto ele está rodando. Código assíncrono lança o erro depois, quando o bloco try já terminou, e o erro precisa achar outra saída. O experimento pega quatro programas curtos do livro, e cada um tenta ler um arquivo que não existe: com callback, com uma cadeia de promises, com async/await e com uma promise cujo resultado ninguém espera.

Escolha uma aba e aperte “Executar”. O programa roda nesta aba, e quatro caixas mostram onde o erro foi parar: no try em volta da chamada, no .catch do fim da cadeia, no try em volta do await ou com ninguém, como um evento no window. Enquanto o programa roda, o widget escuta esses eventos e chama preventDefault() nos próprios erros, para nada vazar no console. O navegador não tem fs, então um setTimeout faz o papel do callback de leitura, e readFile é um substituto que rejeita com ENOENT como o Node.

Ao lado do log do navegador está o que o mesmo código fez no livro, no Node 24. A versão com callback imprimiu “o try terminou sem erros” e em seguida o processo caiu com código 1. O .catch no fim da cadeia pegou ENOENT. Um try/catch comum em volta do await pegou ENOENT. A promise rejeitada que ninguém esperava derrubou o processo com código 1, e a mensagem do timer de 100 ms nunca foi impressa. No navegador esse timer roda, porque a página sobrevive ao que encerra um processo do Node.

O capítulo acompanha quem guarda o resto do programa. No código síncrono quem guarda é a pilha. Os callbacks passaram esse trabalho ao programador, e o try/catch foi junto. Promises e await devolveram o trabalho ao ambiente de execução, o try/catch voltou a funcionar, e a palavra await marca no texto cada ponto em que a função entrega o controle.

_A página tem um experimento interativo que roda no navegador: https://www.mikefluff.com/pt/experiments/js-ch10-lost-error_

## Fontes

- [MDN: Window: unhandledrejection event](https://developer.mozilla.org/en-US/docs/Web/API/Window/unhandledrejection_event)
- [Node.js docs: --unhandled-rejections=mode](https://nodejs.org/api/cli.html#--unhandled-rejectionsmode)
- [MDN: try...catch](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/try...catch)

## Do livro

Ao lado dele no livro:

> Devolveram, porém, com uma ressalva que importa para o próximo capítulo. Os lugares em que a função devolve o controle estão marcados com a palavra await, e o programador responde por eles: entre duas linhas com await, os dados lidos antes podem ficar velhos. O Meteor foi além e tirou até essa palavra. O código no servidor do Meteor parecia totalmente síncrono, e o runtime guardava as continuações inteiras, junto com a pilha. Por que isso acelerava tanto o desenvolvimento e por que mesmo assim foi preciso abandoná-lo é o que conta o décimo primeiro capítulo.

- Ler o capítulo: [Capítulo 10. Continuações](https://www.mikefluff.com/pt/read/from-closures-to-autonomous-systems/ch10) (início livre, o resto no livro completo; Markdown: https://www.mikefluff.com/pt/read/from-closures-to-autonomous-systems/ch10.md)

- Livro: [JavaScript: das closures aos sistemas autônomos](https://www.mikefluff.com/pt/books/from-closures-to-autonomous-systems)
