Introdução (3 min)

Imagine um restaurante. Um cliente pede um prato que não está no cardápio. O que acontece? O garçom, em vez de entrar em pânico, educadamente informa ao cliente sobre a indisponibilidade do prato. Esse é o tratamento de erros, fundamental para uma boa experiência. Em APIs, é vital lidar com situações inesperadas de forma elegante e informativa, evitando quebras e garantindo a continuidade do serviço. Nesta aula, você dominará as técnicas essenciais de tratamento de erros em Node.js e Express, usando try/catch, throw, e erros customizados, preparando-se para construir APIs robustas e resilientes.

No contexto de Node.js/Express, o tratamento de erros é ainda mais relevante devido à natureza assíncrona da plataforma. Saber lidar com erros garante a estabilidade da sua aplicação, mesmo sob grande pressão.

Conceito Fundamental (7 min)

O tratamento de erros é o processo de antecipar, detectar e responder a condições excepcionais que podem interromper o fluxo normal de uma aplicação. Usamos try/catch para encapsular código que pode gerar erros. O bloco try contém o código a ser monitorado, e o bloco catch captura e lida com qualquer erro que ocorra dentro do try. A palavra-chave throw permite lançar erros explicitamente, sinalizando situações problemáticas. Erros customizados são uma maneira poderosa de criar tipos específicos de erros, tornando a depuração e o tratamento mais precisos.

Em produção, o tratamento de erros possibilita o registro (logging) de erros para análise posterior, a exibição de mensagens amigáveis ao usuário, e a recuperação da aplicação em caso de falhas. Integra-se com tecnologias de logging, monitoramento, e frameworks web como o Express.js. A principal vantagem é a robustez, enquanto a desvantagem pode ser um pequeno overhead de performance, insignificante na maioria dos casos.

Implementação Prática (10 min)

const express = require('express');
const app = express();

// Middleware para simular uma operação que pode falhar
const operacaoAssincrona = (req, res, next) => {
  try {
    // Simulando uma busca em um banco de dados
    const resultado = null; // Simulando um resultado nulo (erro)
    if (!resultado) {
      // Lançando um erro customizado
      const erro = new Error('Recurso não encontrado');
      erro.status = 404;
      throw erro;
    }
    res.locals.resultado = resultado; // Armazenando o resultado
    next(); // Passando para o próximo middleware
  } catch (err) {
    console.error('Erro na operação assíncrona:', err); // Logging profissional
    next(err); // Passando o erro para o manipulador de erros global
  }
};
app.get('/recurso', operacaoAssincrona, (req, res) => {
  res.json(res.locals.resultado);
});
// Manipulador de erros global
app.use((err, req, res, next) => {
  res.status(err.status || 500); // Definindo o código de status
  res.json({ erro: err.message }); // Retornando uma resposta JSON com a mensagem de erro
});
app.listen(3000, () => console.log('Servidor rodando na porta 3000'));

Instalação das dependências (apenas uma vez):



    
📚 Informações da Aula

    
Curso: API Completo - Node.js & Express

    
Tempo estimado: 25 minutos

    
Pré-requisitos: JavaScript básico



npm init -y
npm install express


Executar o servidor

node index.js

Este código demonstra o uso de try/catch, throw, e um manipulador de erros global. O middleware operacaoAssincrona simula uma operação que pode falhar, lançando um erro customizado com status 404. O manipulador de erros global captura qualquer erro e retorna uma resposta JSON com o código de status e a mensagem de erro.

Exercício Hands-On (5 min)

Crie uma rota /usuario que busca um usuário por ID. Simule um banco de dados com um array de usuários. Se o usuário não for encontrado, lance um erro customizado UsuarioNaoEncontrado com status 404 e mensagem personalizada. Implemente um manipulador de erros global para tratar esse erro e outros erros que possam ocorrer.

Solução:

// ... (código anterior)

class UsuarioNaoEncontrado extends Error {
  constructor(message) {
    super(message);
    this.name = 'UsuarioNaoEncontrado';
    this.status = 404;
  }
}
app.get('/usuario/:id', (req, res, next) => {
  const usuarios = [{ id: 1, nome: 'Alice' }, { id: 2, nome: 'Bob' }];
  const usuario = usuarios.find(u => u.id === parseInt(req.params.id));
  if (!usuario) {
    throw new UsuarioNaoEncontrado('Usuário não encontrado');
  }
  res.json(usuario);
});
// ... (manipulador de erros global - já implementado anteriormente)

Para testar, faça uma requisição para /usuario/3. Você deve receber uma resposta JSON com status 404 e a mensagem “Usuário não encontrado”. Para outros IDs (1 e 2), você receberá os dados do usuário correspondente. Lembre-se de usar o console.error para registrar os erros de forma profissional. Experimente outras variações e cenários para consolidar seu aprendizado. A partir daqui, explore a documentação oficial do Express.js para aprofundar seus conhecimentos sobre middlewares e tratamento de erros.