Aula 04
Promessas Rejeitadas, Blocos de Try Catch com Async Await no JavaScript
Summary
# Resumo da Aula sobre Promessas Rejeitadas no JavaScript
Nesta aula, exploramos como lidar com promessas rejeitadas no JavaScript, utilizando duas abordagens: a tradicional com `then` e `catch`, e a nova abordagem usando `async/await`.
## Abordagem Tradicional
1. **Definição da Função `Find1`**:
- A função retorna uma nova promessa que é rejeitada após cinco segundos. A rejeição é simulada com a função `setTimeout` que, após 5 segundos, invoca `reject` com uma mensagem de erro.
2. **Uso da Promessa**:
- Chamamos a função `Find1` e utilizamos `then` para processar o valor retornado (se não houver erro), e `catch` para lidar com erros. No nosso exemplo, a chamada a `Find1` resulta em um erro que é capturado pelo bloco de `catch`, exibindo a mensagem de erro de busca.
## Abordagem `async/await`
1. **Uso do `await`**:
- É necessário encapsular a chamada dentro de uma função `async` para usar `await`. Isso permite que a execução pause até que a promessa seja resolvida ou rejeitada.
2. **Estrutura com `try/catch`**:
- Um bloco `try` é utilizado para abrigar a chamada a `Find1`, e se houver um erro, o fluxo é desviado para o bloco `catch`, processando o erro.
3. **Comportamento da execução**:
- Se um erro ocorrer dentro do bloco `try`, a execução vai para `catch`, mas a função não para completamente. Linhas de código após o bloco `try/catch` ainda são executadas, permitindo manejar múltiplos comandos sequencialmente.
4. **Observação sobre o fluxo**:
- A diferença principal é que, com `async/await`, a execução aguarda a resolução da promessa, enquanto que na abordagem tradicional, o código continua a execução imediatamente, sem esperar pela resolução da promessa.
## Conclusão
Ambas as abordagens são válidas, mas `async/await` oferece uma maneira mais legível e intuitiva de lidar com promessas e seu tratamento de erros. A aula aprofundou essas diferenças e mostrou exemplos práticos de uso.
Agradecemos pela participação e até a próxima aula!
Video Transcript
Nesta aula, nós vamos dar uma olhada em como lidar com promessas rejeitadas no S5O8.
Primeiro de tudo, vamos começar com como a gente faz para lidar com promessas rejeitadas
da maneira usual usando a cadeira de promessas com o bloco de then e o bloco de catch.
O Pouco tem uma função Find1, essa maneira aqui.
Vamos chamar a função Find1.
Essa função Find1, ela vai retornar a nova promessa.
Nesse caso, vamos fazer a promessa ser rejeitada.
Então, o que eu vou fazer?
Vamos ter que finalizar com o Pouco.
Então, eu vou retornar a nova promessa, a nova promessa.
Faço aqui a função com o primeiro argumento resolve, segundo reject.
Eu vou usar o reject, não vou usar o resolve aqui, só para poder ilustrar o negócio.
Essa função aqui, vamos dar o set timeout para poder dar aquele delay.
Depois de cinco segundos, que é 5 mil milis segundos, que é igual a cinco segundos,
a gente vai executar o reject e vai passar um novo erro, new error, e deu problema aqui.
Deu problema na busca, por exemplo.
Então, essa função Find1 retorna uma promessa, que depois de cinco segundos vai ser rejeitada
com um erro, com a mensagem de um problema na busca.
Normalmente, quando você faz, por exemplo, se eu chamo Find1 dessa maneira,
a gente vai ter que dar o then para poder ver se tinha algum valor.
Vamos supor que o Find1 retorna a conta do usuário, depois que resolve a promessa.
Uma coisa assim, aí você faz alguma coisa aqui.
Mas nesse caso, não vai dar aqui, porque a gente já falou que vai rejeitar depois de cinco segundos.
Então, se a promessa for rejeitada, a gente usa aquele bloco de catch.
Deixa eu botar ensinando novo link aqui para você ver melhor.
Então, a cadeia de promessas aqui pode ter vários then, mas eu vou fazer com um,
só para deixar simplificado.
Aí, no bloco de catch, ele vai pegar o erro aqui, que aconteceu quando você chamar o Find1.
Opa, deu um negócio aqui.
Depois de cinco segundos, vai ser rejeitada essa promessa, porque vai ser rejeitada,
vai para o bloco de catch e a gente vai falar alguma coisa aqui.
Vamos falar aqui a promessa retornada pelo Find1 foi rejeitada.
Aí, vou botar o...
Deixa eu habilitar o software aqui.
Aí, eu vou dar o console logo também do where.message, que vai ser a mensagem de erro que veio aqui, esse erro.
Vamos ver no que dá quando a gente chama esse Find1 aqui.
Vou salvar esse arquivo no promesscat.js aqui que eu criei e dessa vez eu vou para o terminal.
Aí, eu estou aqui com a versão do node 8.12.0, certo?
Isso eu vou rodar esse arquivo que eu já tenho aqui, promesscat.js node, o nome do arquivo.
Ele vai rodar esse cara.
Depois de cinco segundos, vai dar o console logo.
Está aí. Então, o script terminou e mandou a mensagem para o mestre retornado pelo Find1, foi rejeitado.
Esse aqui é where.message, que foi aquele deu problema na busca que vem do valor do erro da promessa, certo?
Essa é a maneira usual que a gente lida com os erros, mas agora como é que a gente faz essa mesma coisa usando o a5o8?
Então, eu vou deixar esse cara aqui embaixo, eu vou comentar e eu vou fazer o a5o8 aqui em cima, certo?
Então, vamos fazer o seguinte. Você vai chamar o Find1, o Find1 retorna o cara, né?
Então, bota o y-weight antes do Find1, porque o Find1 vai retornar o promessa, o await vai desimprilhar a promessa
e o valor vai ser, a gente põe uma variável, vamos chamar a variável de conta dessa maneira aqui.
Aí você faz o que quiser com a conta, nessa maneira, mas para poder pegar o catch aqui desse cara aqui, da execução do Find1,
você tem que botar o bloco de try catch. Você faz o try, aí põe as coisas que você quer tentar, né?
Aí põe o catch aqui, qualquer erro dessa maneira, então o bloco de try com o catch.
Então, você vai tentar fazer esses comandos aqui e se der algum problema em qualquer comando aqui dentro do bloco do try,
ele vai imediatamente para o catch. Então, a gente já sabe que isso é chamado para o Find1,
vai retornar o projeto com a promessa rejeitada, por isso vai dar um erro, né?
Então, vai dar um problema no bloco de try, aí vai lá para o catch, esse erro aqui vai ser esse novo erro com o mensagem
de um problema na busca. A gente vai fazer a mesma coisa aqui.
Try, deu problema. Aí eu põe error.message para ver o que é.
Vamos ver o que acontece. Vou salvar aqui, vou rodar de novo lá no terminal, ver no que dá.
Ah, o que é que aconteceu? O wait, somente vale do na função, a5.
Tem aquela mesma coisa de antes, a gente tem que sempre, só pode usar o wait se estiver dentro da função a5.
Então, eu vou fazer a função a5 aqui, sei lá, vou chamar de rodar e eu vou botar esse cara dentro da função
e chamar a função, porque o wait só pode ser usado dentro da função a5.
Aí, vou rodar o rodar aqui, certo? Dessa maneira. Então, aqui só é a definição da função
para poder executar os comodos aqui dentro desses caras para se chamar o rodar.
Então, eu salvava, vamos tentar novamente aqui no terminal, põe de 5 segundos, vamos ver no que dá.
Try deu problema, deu problema na busca, certo? Então, vamos voltar e revisar o que a gente fez.
Então, agora com a5 e o wait, você vai ter que fazer blocos de try and catch.
Aí dentro do try, qualquer comando, pode ser qualquer linha que dá problema, ele vai imediatamente para o bloco de catch.
Aí, com o erro que dá a linha nesse caso do find one, certo?
Aí, não precisa ter somente um para ter vários comandos aqui, ele vai no catch aqui.
Um detalhe aqui, é que esse try catch, qualquer coisa que dá problema aqui, ele vai imediatamente para o catch,
mas não significa que toda a função vai parar, você pode botar mais coisas aqui embaixo.
Terminando o rodar, por exemplo. Então, ele vai começar no try, vai chamar o wait, esperar,
e quando obter a resposta, que foi o erro, vai para o catch, faz esse cara,
aí depois disso continua normalmente e vai dar o terminando rodar, o console logo, qualquer comando aqui, certo?
Vamos lá ver de novo o que acontece. Vamos no terminal, vou rodar novamente, depois cinco segundos,
note que não tem nada aqui, está esperando cinco segundos, depois cinco segundos, try, deu problema,
e seguido daquela mensagem terminando o rodar, lá aqui no final do rodar.
Então, você vê que nesse cara, ele espera, porque tem o wait, o wait vai esperar esse cara terminar
e obter a resposta que foi rejeitada, da promessa rejeitada, e se der pau vai para o catch,
e embora que tenha o erro, ainda vai continuar com os outros,
com as outras linhas da própria função, do bloco da função, não vai parar,
assim, não vai terminar a execução de toda a função, e também não vai continuar a síncrono,
porque se a gente tivesse feito dessa maneira aqui, ele não iria esperar para o then, para chegar,
ou para o catch chegar, ele iria continuar e dar o console logo, você pode ver aqui, deixa eu comentar aqui,
comenta o rodar e volta para o atério, e eu pegar esse console logo terminando o rodar,
aqui, vamos ver no que dá, find one, then catch, o console logo terminando o rodar, lá embaixo,
vamos ver no que dá, terminal, roda de novo, ou você note que já apareceu terminando o rodar,
antes dos cinco segundos, e aí finalmente a promessa retornada, que deu problema, depois cinco segundos,
então é muito diferente, note isso, que no caso, o a5a vai esperar a resposta,
mas quando você faz a cadeia de promessa da forma usual, normalmente ele não vai esperar esse cara terminar,
já continua na próxima linha, tem esse detalhe.
Certo, espero que você tenha gostado da nossa aula e até a próxima, muito obrigado.
Nenhum comentário ainda (loading...)
Nenhum comentário ainda (loading...)
Gostou da aula? 😆👍
Apoie nosso trabalho com uma doação: