Uma breve análise do middleware de tratamento de erros do Express em Node

Como começar rapidamente com o VUE3.0:

O middleware de tratamento de erros do Learn Express pode ajudá-lo a lidar com erros sem repetir o mesmo trabalho. Supondo que você lide com erros diretamente no manipulador de rota Express:

app.put('/user/:id', async (req, res) => {
  deixe o usuário
  tentar {
    usuário = aguarda User.findOneAndUpdate({ _id: req.params.id }, req.body)
  } pegar (errar) {
    retornar res.status(err.status || 500).json({ mensagem: err.message })
  }
  retornar res.json({usuário})
})

O código acima funciona bem, no entanto, e se houver centenas de interfaces, a lógica de tratamento de erros se tornará impossível de manter porque é repetida centenas de vezes.

Definindo o middleware de tratamento de erros

O Express é dividido em diferentes tipos de acordo com o número de parâmetros que a função do middleware assume. A função de middleware que aceita 4 parâmetros é definida como middleware de tratamento de erros e só será chamada quando ocorrer um erro.

const app = require('express')()

app.get('*', function routeHandler() {
  // Este middleware gera um erro e o Express irá diretamente para o próximo manipulador de erros throw new Error('Oops!')
})

app.get('*', (req, res, próximo) => {
  // Este middleware não é um manipulador de erros (apenas 3 parâmetros), o Express irá ignorá-lo porque há um erro no middleware anterior console.log('This will not beprint')
})

// Sua função deve aceitar 4 parâmetros para que o Express a trate como um middleware de tratamento de erros.
app.use((err, req, res, próximo) => {
  res.status(500).json({ mensagem: err.message })
})

O Express tratará automaticamente os erros de sincronização para você, como routeHandler() acima. Mas o Express não lida com erros assíncronos. Se ocorrer um erro assíncrono, next() precisa ser chamado.

const app = require('express')()

app.get('*', (req, res, próximo) => {
  // O método next() diz ao Express para ir para o próximo middleware da cadeia.
  // Express não lida com erros assíncronos, então você precisa reportar erros chamando next().
  setImmediate(() => {
    próximo(novo erro('Opa'))
  })
})

app.use((err, req, res, próximo) => {
  res.status(500).json({
    mensagem: err.mensagem
  })
})

Lembre-se de que o middleware Express é executado sequencialmente. Você deve definir os manipuladores de erros por último, depois de todos os outros middlewares. Caso contrário, seu manipulador de erros não será chamado:

async/await

Express com async/await não pode capturar exceções de promise , Express foi escrito antes do ES6 e não há uma boa solução para lidar async/await que ele lança.

Por exemplo, o servidor a seguir nunca envia a resposta HTTP com êxito porque a reject da promessa nunca é tratada:

const app = require('express')()

app.get('*', (req, res, próximo) => {
  // O relatório de erros assíncronos deve passar por next()
  retornar nova Promessa((resolver, rejeitar) => {
    setImmediate(() => rejeitar(novo erro('uau')))
  }).catch(próximo)
})

app.use((erro, req, res, próximo) => {
  console.log('não será impresso')
  res.json({ mensagem: erro.mensagem })
})

app.listen(3000)

ou usar uma biblioteca existente para capturar.

Primeiro, simplesmente encapsulamos uma função para conectar async/await com o middleware Express de tratamento de erros.

NOTA : As funções assíncronas retornam Promise, então você precisa ter certeza de catch() quaisquer erros e passá-los para next() .

função wrapAsync(fn) {
  função de retorno(req, res, próximo) {
    fn(req, res, próximo).catch(próximo)
  }
}

app.get('*', wrapAsync(async (req, res) => {
  aguarde nova promessa(resolver => setTimeout(() => resolver(), 50))
  // Erro assíncrono!
  lançar novo erro ('uau')
}))

Use a biblioteca de terceiros express-async-errors , um simples hack de suporte async/await do ES6:

require('express-async-errors')
app.get('*', async (req, res, próximo) => {
  aguarde nova promessa((resolver) => setTimeout(() => resolver(), 50))
  lançar novo erro ('uau')
})

Finalmente,

o middleware Express de tratamento de erros permite tratar erros de uma forma que maximiza a separação de interesses. Você não precisa lidar com erros em sua lógica de negócios, nem mesmo try/catch se estiver usando async/await . Esses erros aparecerão no seu manipulador de erros, que poderá então decidir como responder à solicitação. Aproveite esse recurso poderoso em seu próximo aplicativo Express!