‫Homem: Neste vídeo, vamos implementar o
‫middleware de tratamento de erros global sobre o
‫qual falamos antes.
‫Portanto, lembre-se de que o
‫objetivo é escrever uma função de
‫middleware, que será capaz de lidar com erros operacionais como este.
‫Ok, então quando um usuário acessa uma URL que não existe,
‫podemos considerar isso um erro operacional, e
‫neste caso tratamos disso enviando de volta
‫essa resposta aqui, certo?
‫Mas, novamente, o objetivo é fazer isso em um local central.
‫Por exemplo, temos coisas semelhantes aqui.
‫Então, em todo lugar aqui temos esses trechos
‫aqui, que tratam dos erros.
‫Portanto, temos que golpear o bloco etch aqui, e se
‫houver um erro, bem, então lidamos
‫com isso enviando esse erro para o cliente.
‫E, novamente, no final, queremos nos livrar
‫de tudo isso e lidar com o erro
‫em um middleware central.
‫E então vamos começar criando
‫essa função de middleware.
‫E no Express, é realmente muito fácil.
‫Lembre-se de como eu disse a você que
‫o Express já vem com manipuladores de
‫middleware prontos para uso.
‫Como sempre, começamos usando o app. use, ok, e então
‫aqui definimos nossa função de middleware.
‫Portanto, para definir um middleware de tratamento
‫de erros, tudo o que precisamos fazer é fornecer
‫à função de middleware quatro argumentos e o Express irá
‫reconhecê-lo automaticamente como um middleware de tratamento de erros.
‫E, portanto, só chame quando houver um erro.
‫E assim, como em muitos outros casos, essa função de
‫middleware é uma função de erro primeiro, o que
‫significa que o primeiro
‫argumento é
‫o erro e, em seguida, temos a solicitação, a resposta e o próximo.
‫Portanto, ao especificar quatro parâmetros, o Express sabe automaticamente
‫que toda a função aqui é um
‫middleware de tratamento de erros.
‫Portanto, agora vamos implementar o código para essa função aqui e, depois
‫disso, mostrarei como podemos realmente criar um
‫erro para que essa função de middleware seja
‫realmente capturada.
‫Portanto, em duas etapas, primeiro criamos o middleware e, em
‫seguida, na segunda etapa,
‫criaremos realmente um erro para que essa função seja detectada.
‫E, por enquanto, vamos mantê-lo bem simples aqui.
‫Portanto, tudo o que realmente queremos fazer
‫para lidar com esse erro é enviar uma resposta ao cliente.
‫Então res. status, mas agora
‫não sabemos realmente qual é o código de status, certo?
‫Por exemplo, neste caso aqui é um 404, mas temos
‫alguns erros aqui, que têm outros códigos de status.
‫Como temos um 400, por exemplo, para solicitação incorreta ou, na
‫verdade, todos os tipos de outros códigos.
‫E então realmente queremos ler o
‫código de status do objeto de erro, certo?
‫Então, quando criarmos esse erro um pouco mais
‫tarde na segunda etapa,
‫como eu disse a vocês, definiremos esse código de status no erro.
‫Então, digamos o código de status, e agora quero definir
‫um padrão aqui.
‫Porque haverá erros que não virão de nós,
‫porque haverá erros sem um código de
‫status, portanto, erros que não são criados
‫por nós, mas por exemplo em alguns outros lugares no
‫aplicativo de notas.
‫E eu sei que parece um pouco confuso por enquanto,
‫mas você verá ao longo desta seção.
‫Por enquanto, vamos realmente definir este código de
‫status padrão.
‫Portanto, dizemos que o erro. statuscode é
‫igual a err. statuscode basicamente se é
‫definido ou o código 500, o que significa novamente, erro interno do
‫servidor, e então esse é geralmente o
‫padrão que usamos.
‫E da mesma forma, também definimos o status,
‫então digamos erro. status é igual a erro. status se estiver
‫definido, e se não, é
‫erro.
‫Portanto, o erro, lembre-se, é quando temos um código de status 500 e se
‫for um código de status 400, é uma falha.
‫Então, por exemplo, aqui neste 404, o status é falha.
‫E agora aqui
‫podemos usar isso, portanto, erro. statuscode e, em seguida, enviar algum json,
‫muito semelhante ao que fizemos antes.
‫Portanto, começamos com o status e o lemos a partir do erro. status e a
‫mensagem virá do erro também.
‫Então erre. mensagem e vou mostrar em um
‫segundo como isso errou. a propriedade da mensagem aqui é criada.
‫Tudo bem, mas por enquanto, este é o nosso middleware de tratamento
‫de erros muito simples.
‫Muito simples, mas por enquanto funciona.
‫E agora a segunda etapa, em que
‫realmente criamos um erro.
‫E então vamos fazer isso aqui.
‫Bem aqui nessa função, que lida com todas
‫as rotas não tratadas, deixe-me comentar esta
‫aqui e, em vez disso, queremos criar um erro.
‫Digamos que const err e
‫seja um novo erro.
‫Portanto, basicamente usamos o construtor de erro embutido
‫para criar um erro.
‫E agora podemos passar uma string e essa string
‫será a propriedade da mensagem de erro.
‫Então, o que acabamos de falar aqui.
‫Portanto, essa mensagem deve ser esta mensagem.
‫Tudo bem?
‫E então deveria dizer errar. status que é
‫falha
‫e, em seguida, errar. statusCode é igual a 404.
‫Isso é o que mencionei antes que podemos definir o
‫código de status e o status no objeto de erro.
‫E isso é exatamente o que estamos fazendo aqui.
‫Estamos criando um erro e, em
‫seguida, definimos o status e as propriedades do código de status nele
‫para que nosso middleware de
‫tratamento de erros possa usá-los na próxima etapa.
‫Mas agora, como realmente lemos a próxima etapa?
‫Então, esse próximo middleware.
‫Bem, como sempre, usamos a seguir.
‫Mas desta vez usamos o próximo de uma maneira especial.
‫Porque agora precisamos realmente passar esse erro para
‫o próximo, então se a próxima função receber um
‫argumento, não importa qual seja, o
‫Express saberá automaticamente que houve um erro, então assumirá
‫que tudo o que passarmos para o próximo
‫será um erro.
‫E isso se aplica a todas as próximas funções em cada
‫middleware em qualquer lugar em nosso aplicativo.
‫Então, novamente, sempre que passarmos algo para o próximo, ele
‫assumirá que é um erro e, em seguida, irá
‫ignorar todos os outros middlewares na pilha de
‫middleware e enviar o erro que passamos para o
‫nosso middleware de tratamento de erros global, que
‫então , é claro, ser executado.
‫E então vamos passar o
‫erro que irá pular novamente, todos os
‫outros middlewares na pilha e ir direto para este.
‫Agora, neste caso,
‫não há nenhum outro middleware no meio, certo?
‫Portanto, é realmente apenas o próximo
‫aqui, mas se usarmos next e passarmos um erro em
‫outro lugar, é claro que funcionará da mesma forma.
‫E então vamos agora testar tudo
‫isso simplesmente tentando acessar uma rota que não foi definida.
‫E então isso irá acionar todo esse código aqui, pular para o
‫middleware de tratamento de erros e, em seguida, enviar
‫de volta a resposta com base em toda
‫essa lógica aqui.
‫Então, aqui ainda temos nossa rota errada ou inexistente e
‫vamos começar realmente chamando esta, que ainda
‫deve estar funcionando, ok,
‫então, apenas para confirmar
‫que tudo está funcionando bem e funciona, e
‫agora este.
‫E, de fato, não conseguimos encontrar tours de barra de API neste servidor e,
‫portanto, nosso middleware de tratamento de erros global
‫está realmente fazendo seu trabalho.
‫Perfeito, esse é o primeiro passo para realmente implementar um
‫mecanismo de tratamento de erros muito melhor
‫em nosso aplicativo.
‫Portanto, podemos prosseguir e tentar implementar esse
‫tipo de coisa aqui, em todos os
‫nossos gerenciadores.
‫Por exemplo, aqui em todas essas funções que temos
‫aqui.
‫Então, substituindo tudo o que temos aqui por
‫esse tipo de erro.
‫Mas o que quero fazer agora é realmente criar
‫nossa própria classe de erro.
‫Para que não tenhamos que escrever todo esse código aqui e,
‫em vez disso, ter uma classe mais simplificada de
‫nós mesmos.
‫Essa é uma prática comum e vamos fazer isso no
‫próximo vídeo.