Aprenda a lidar com promessas de JavaScript com o novo paradigma do async e await.

JavaScript: Async / Await

Gestão de Promessas no JavaScript com o Async Await

# Resumo da Aula sobre Async e Await no JavaScript

Nesta aula, aprendemos sobre **Async** e **Await**, introduzidos no **ECMAScript 2017**, que simplificam o manuseio de promessas (promises) no JavaScript.

## Revisão das Promessas

1. **Função FindOne**: Exemplifiquei uma função que busca a conta de um usuário no banco de dados pelo ID.
   - Essa função retorna uma promessa.
  
2. **Uso de .then()**:
   - Para lidar com a promessa, usamos o método `.then()`.
   - O que se espera é que, se a conta for encontrada, um objeto com os dados da conta é retornado; caso contrário, uma mensagem de "conta não encontrada" é exibida.

   ```javascript
   FindOne(id)
     .then(conta => {
       console.log("Conta encontrada:", conta);
     })
     .catch(() => {
       console.log("Conta não encontrada");
     });
   ```

## Introdução ao Async/Await

1. **Simplificação do Código**: Com a introdução de `async` e `await`, a maneira de lidar com promessas fica mais limpa e fácil de entender.

2. **Uso de Await**:
   - Para usar `await`, colocamos antes da chamada de uma função que retorna uma promessa.
   - `await` faz com que o código "espere" pela resolução da promessa antes de continuar.

   ```javascript
   async function buscarConta(id) {
       const conta = await FindOne(id);
       console.log("Conta encontrada:", conta);
   }
   ```

3. **Diferença Principal**:
   - O `await` espera o resultado antes de prosseguir para a próxima linha de código, enquanto o `.then()` não espera, permitindo que o código continue a execução.

## Considerações Finais

- O uso de `async` e `await` fornece uma maneira mais intuitiva e legível de lidar com operações assíncronas em JavaScript.
- Na próxima aula, continuaremos explorando mais sobre o uso de `async` e `await`.

**Até a próxima!**

Nesta aula nós vamos aprender sobre o Async e Oate, uma nova maneira de lidar com promessas
no JavaScript.
O Async e Oate foi introduzido com o AcmaScript 2017, padrão do AcmaScript 2017, aí já vai
dar pra usar Async e Oate.
Então pra começar vamos primeiro revisar como é que a gente lida com as promessas, a maneira
usual, antes do Async e Oate.
Vamos aqui no editor de texto pra gente escrever um código.
Então vamos supor que você tenha essa função aqui, chamada FindOne, você tá trabalhando
com um aplicativo, aí você tem que fazer o login do usuário.
Vamos supor que no banco de dados tem uma tabela com as contas dos usuários.
Então vamos encontrar a conta do usuário usando o ID dessa conta.
Então essa função FindOne vai levar com argumento aqui o ID da conta.
Vamos supor que o ID da conta é 1, 2, 3, 4.
Então vamos supor que tenha essa função chamada FindOne que leva como argumento aqui, o parâmetro
pra busca no banco de dados.
Então vamos buscar pela conta de ID 1, 2, 3, 4.
Agora a conta pode existir ou a conta pode não existir.
Então a gente vai ver isso quando a gente lida com esse cara aqui.
Vamos supor que a função retorna a promessa.
Como é que a gente lida com a promessa?
Como eu falo promessa é a promise.
Então normalmente a gente fala o ponto Den, aí aqui o argumento vai ser uma função.
Normalmente se é assim, você põe a variável aqui que vai conter o valor daquilo que foi
encontrado pela sua busca.
Nesse caso vai ser um objeto da conta do usuário.
Ou se não encontrar vai ser no...
Aí vamos botar uma função aqui de set ou flash pra definir o que a gente como lida com
a promessa.
A gente chama o FindOne, aí dá o dot Den, aí se tu desce a nossa busca aqui no banco
de dados a função aqui retorna a promessa.
A gente vai lida com o promessa ponto Den e o valor objeto conta aqui.
Aí vamos supor, a gente não vai entrar em detalhes na implementação, quero só dar
um console log assim por exemplo.
Então se for o caso aqui não vai encontrar a conta vai ser no e a gente vai dar o console
log conta não encontrada.
Aí vai dar um return porque a gente não precisa mais fazer nada, não encontrou.
Aí se a conta estiver existe esse cara aqui não vai ser executado, então essa parte
não vai ser executada, vai pra essa parte aqui vamos dizer que conta foi encontrada.
Aí vamos dar o console log da conta mesmo.
Então é assim que a gente faz pra lidar com a promessa usando o dot Den.
Mas agora tem esse negócio de a5 await, foi introduzido no Mac
ManScript 2017 e como é que a gente vai fazer pra usar o a5 await?
Então o a5 await vai fazer esse processo aqui de lidar com a promessa um pouco mais simplificado
e não vai ter precisado adicionar esse bloco aqui de Den dessa maneira.
Então vamos ver como esse cara fica quando você usar o a5 await.
Então vamos escrever a mesma coisa aqui embaixo.
Então a gente vai dar o find1 da mesma maneira, um argumento, um objeto com id 1, 2, 6, 4 da
conta do usuário.
Aí em vez de falar ponto Den a gente vai fazer o seguinte, a gente vai botar await
antes da chamada da função.
A gente sabe que o find1 retorna a promessa.
Aí pra lidar com a promessa a gente vai usar o await antes da chamada.
Aí você vai pôr a conta aqui no lado esquerdo.
Por que?
Porque o que o await faz é o seguinte, ele pega o valor que foi fornecido pela promessa
aqui do find1 se tudo der certo, se der sucesso e pega o valor e põe dentro dessa variável
aqui conta.
Note se você não tiver o await dessa maneira aqui, esse cara retorna o promessa, então
conta vai armazenar o quê?
Armazenar uma promise.
Mas a gente não quer a promise, a gente quer o valor fornecido pela promessa se tudo
der certo.
Então tem que ter o await pra poder desembrular aquela promessa.
Aí você faz a mesma coisa que fez antes, é só botar aqui e um detalhe que o await
vai fazer um negócio síncron, ele vai, quando você chega nessa linha aqui, ele vai chamar
sua função e vai esperar até que a promessa seja realizada aqui.
E depois que esse valor for retornado, fornecido, é que ele vai armazenar e depois disso vai
continuar com os outros comandos.
Então tem esse detalhe que o cara com o await, você tem que esperar por essa linha ser terminada,
né?
O processo aqui de fazer pedido pro banco de dados e receber os dados e mandar o valor
fornecido pra variável, vai esperar tudo.
Certo?
É diferente do anterior, né?
Se você fizer desse jeito aqui, ele não vai esperar pra poder executar os comandos
posteriosos aqui que vem depois, certo?
Essa maneira anterior, ele não vai esperar que o find1 termine pra poder continuar com
os outros, as outras linhas, esse detalhe.
Certo?
Então, por esse vídeo é só e a gente vai continuar no próximo vídeo.
Até mais.


000a-01 Gestão de Promessas no JavaScript com o Async Await

Prática do JavaScript Async Await no Console

# Resumo da Aula sobre Implementação de Promessas em JavaScript

### Introdução
A aula se concentrou em ensinar sobre a criação de uma função chamada `find1`, que simula a busca de um objeto de usuário em JavaScript.

### Implementação do `find1`
- **Definição da Função**: 
  - `function find1(query) { ... }`
  - A função retorna uma promessa resolvida (`Promise.resolve`) com um objeto de usuário contendo um `id` de 1234.
  
```javascript
function find1(query) {
    return Promise.resolve({ id: 1234 });
}
```

### Testando a Função
- Testado no console do navegador. Ao chamar `find1()`, obteve-se uma promessa com o valor esperado.
- Utilizou-se `.then()` para manipular o valor retornado pela promessa e logou-se o objeto no console.

### Uso de `async` e `await`
- Para utilizar `await`, é necessário estar dentro de uma função `async`.
- Uma nova função chamada `login` foi criada para demonstrar o uso de `await`.

```javascript
async function login() {
    const conta = await find1();
    console.log(conta);
}
```

### Atraso na Resolução da Promessa
- A função `find1` foi modificada para incluir um atraso de 5 segundos usando `setTimeout`, simulando uma operação assíncrona real.

```javascript
function find1(query) {
    return new Promise((resolve) => {
        setTimeout(() => {
            resolve({ id: 1234 });
        }, 5000);
    });
}
```

### Verificação do Comportamento do `await`
- Ao executar a função `login` após a redefinição de `find1`, confirmou-se que o `await` pausa a execução do código até que a promessa seja resolvida.

### Conclusão
- A aula mostrou como implementar e testar promessas em JavaScript, bem como a importância de usar `async` e `await` para gerenciamento de código assíncrono. 
- O uso de um atraso na função `find1` forneceu uma compreensão prática de como o `await` funciona em relação ao fluxo de execução em um ambiente assíncrono.

---

### Próximos Passos
- Continuar explorando mais sobre promessas e manipulação de dados assíncronos em JavaScript nas próximas aulas.

Vamos continuar a aprender o i5o8.
Então vamos definir o find1.
Vamos fazer nossa própria implementação aqui.
Não vai ser a implementação real, mas vai ser só um fad de conta aqui para a gente poder testar.
Deixa eu abrir uma nova tab aqui.
JavaScript.
Então vamos definir o find1.
Function.
Find1.
Aí tem um argumento para o que vai ser o objeto da query.
Vamos chamar de query.
Aí...
Então...
O find1 vai retornar a promessa, não é?
Então vamos só retornar uma nova promessa aqui.
Vamos retornar a promessa já resolvida com um objeto da conta do usuário.
Então a gente vai fazer o seguinte, vai só pôr aqui promise.resolve
e um objeto do usuário, vamos botar o id 1234.
E pode ter outros campos que eu não vou digitar, certo?
Nome, email, essas coisas.
A gente quer focar aqui no i5o8 e promessas, então eu não vou adicionar mais coisas.
Então a implementação é bem simples, só de leve aqui, não é a real,
é só para a gente poder testar aqui os nossos exemplos.
Então find1, leve o query lá, que nem precisa ter ou não nesse caso,
mas só para a gente retornar a promise que já vai ser resolvida automaticamente aqui
porque a gente vai dar o promise resolve com o objeto, certo?
Então a promessa é retornada do find1.
Aí com isso, o que a gente vai fazer?
Vamos pegar isso agora aqui e vamos testar lá no console do navegador.
Eu vou abrir o Firefox, você pode usar qualquer navegador que você popular que você tiver aí
e abrir o console, certo?
Então já tenho aqui o Firefox aberto com o console, então vou colar a definição do método,
do função find1, tá certo?
Vamos só testar esse cara, vamos chamar o find1, nem precisa dar nenhum argumento
porque é uma função de implementação falsa, certo?
Então vou dar o find1, o que é que você vai, o que é que vai acontecer
quando a gente está aqui, find1 e apertar o enter?
Se note que a gente obtemos uma promessa com o valor retornado, né?
A gente já esperava isso porque a gente deu um return promise já lá
mas quando a gente está fazendo essas coisas a gente não quer saber da promessa,
a gente quer saber daquele valor que é fornecido pela promessa, né?
Fullfilled, o valor que foi fullfilled realizado aqui da promessa.
Então para isso a gente normalmente dava aquele den, como a gente vai falando no vídeo anterior,
deixa eu só dar um console log aqui, den conta e dar um console log,
conta para você ver o que é, não é?
Então depois de den para lidar com o promessa, o valor fornecido pela promessa
vai para variável conta e a gente deu o console log aqui,
já recebeu o objeto com o id1234, como a gente esperava porque a gente já tinha posto aqui.
Agora, como é que a gente vai fazer usando await?
Então a gente faz o seguinte, olha aqui, await, find1, né?
Aí, dessa maneira aqui.
Agora vai ter um detalhe aí, olha o que aconteceu.
await is only valid in async function.
Yeah, async generator.
Então está dizendo que você só pode usar o await dentro de uma função async,
função async ou os geradores async.
Então o que significa isso? Significa o seguinte,
para poder sempre usar o await, esse comando aqui tem que estar dentro de uma função async.
Para você definir a função async, é só fazer uma função assim, olha,
função normalmente, aí você põe o async antes da palavra chave função, function, certo?
Só isso, só adicionar o async.
Mesma coisa para a função de flash, você vai async dessa maneira aqui, certo?
Antes dos parênteses.
Certo?
Então vamos criar uma função aqui, chamada login.
Então vou fazer uma função aqui, certo?
Vamos chamar essa função de login para logar.
Como a gente vai ter que usar o await, a gente vai ter que põe async.
Então você define assim, aí dentro dessa função,
vamos usar aquele await find1 que a gente já tinha executado anteriormente.
Então agora vai funcionar porque esse cara aqui está dentro de uma função async, certo?
Agora, se eu botar o await find1, o cara vai realizar,
vai pegar o valor da promessa aqui, mas não vai fazer nada.
Então eu vou dar o console logo para você ver, né?
Console log await find1, vamos ver aí.
Então, a PTA entra, aconteceu nada porque isso aqui só é a definição da função.
A gente precisa executar a função fazendo login com os parênteses, certo?
Então quando eu executei o login, vai chamar aqui dentro, primeiro find1,
o find1 vai lá em cima, torna a promessa que resolve com o objeto.
Aí pega aquele cara, espera, retornar, aí pega aquele valor e dá o console logo do objeto aqui, certo?
Está aqui.
Está certo?
Então é isso.
Sempre lembre que se você quiser usar o await, tem que pôr o async ali.
E como a gente já disse antes, para a gente poder testar se realmente o await espera para essa linha executar em vez de executar os outros,
vamos fazer o seguinte aqui.
Vamos redefinir o find1 aqui, essa função e dar um set time out para poder adicionar um delay.
Então eu vou redefinir o find1 aqui, vou dar um return, deixa eu dar o set time out aqui.
Deixa eu ver, vamos ver esse cara.
Estou na nova promessa, vamos escrever lá no editor de texto, voltar aqui.
Então vou escrever outra implementação do find1, desta vez vamos adicionar um delay para esperar um pouquinho antes de resolver a promessa.
Function find1, eu nem me precisava por o argumento aqui, que eu não estou usando o mesmo.
Return, nova promessa, new promise, primeiro argumento resolve, reject, eu não vou usar reject, mas deixa aí mesmo.
Então eu vou dar o set time out, se lembra dessa função aqui para poder esperar antes de executar uma função.
Então eu vou esperar quanto tempo aqui? Vamos esperar uns 5 segundos.
Então aqui é 5 mil milis segundos, que significa 5 segundos.
Aí depois de 5 segundos essa função vai ser executada.
O que é que eu quero executar dessa função? Eu quero dar o resolve, vou resolver a promessa com um objeto aqui.
Então vou te explicar o que vai acontecer quando a gente chamar o find1.
Ele vai chamar aqui, vai tornar uma nova promessa.
Essa promessa aqui, você vai dar o set time out, depois de 5 segundos, é que a promessa vai ser resolvida com um objeto aqui, certo?
Então eu adicionar aquele delay para a gente ver se realmente ele espera, o await espera o comando ser executado antes de executar as próximas linhas.
Deixa eu ver aqui no... Deixa eu abrir o outro...
Botando aqui para o console do navegador, vou redefinir o find1, colei aqui, certo? Find1, deixa eu só testar dessa maneira aqui.
Eu executei o find1, dá uns 5 segundos aí.
2, 3, 4, 5, HD, vou abrir aqui.
Ainda está pene, acho que não atualiza aqui mesmo.
Então vamos ver aqui no updend, conta, solar, conta, vamos ver aqui.
1, 2, 3, 4, 5...
Está aí, veio aqui depois de 5 segundos.
Então está tudo funcionando direitinho.
Agora vamos lá voltar ao nosso exemplo do login aqui.
Eu quero testar esse login aqui.
Vou copiar e colar de novo.
Está dentro da função async.
Ele dá o await, o find1.
Vamos botar esse cara aqui dentro de uma variável chamada conta.
Então você vai dar o find1, nem preço de argumento aqui, mas só para você fazer mais sentido.
Então vai dar o find1, retorna o promessa depois de 5 segundos.
Aí esse valor que foi retornado aqui, fornecido, realizado pela promessa, vai para a variável conta.
Aí depois de 5 segundos, ele vai dar o console log.
Deixa até a adicional terminou aqui.
Então você vai ver se o async realmente espera esse comando executar,
ele não vai executar o console log aqui de baixo.
A gente espera que isso aconteça.
Então eu defini a função async, vamos chamar a função.
1, 2, 3, 4, 5...
Nenem deu o console log só depois de 5 segundos que deu o console log da conta e finalmente terminou.
Isso confirma que o almeite realmente espera o comando executar antes de continuar os próximos comandos,
próximos linhas do código.
Então por essa aula é só e até a próxima.


000a-02 Prática do JavaScript Async Await no Console

O Valor Retornado Pela Função Async no JavaScript

# Resumo da Aula sobre SYNC O8

Nesta aula, aprendemos sobre a palavra-chave `async` e seu impacto no retorno de funções em JavaScript.

## Estrutura da Aula

1. **Introdução à Função `obterDados`**:
    - Criamos uma função chamada `obterDados` que retorna uma lista de três objetos, cada um com uma propriedade `ID`.

2. **Adicionando `async`**:
    - Modificamos a função para `async obterDadosDois`.
    - Ao chamar `obterDados`, em vez de retornar os objetos diretamente, foi retornada uma promessa.

3. **Manuseio de Promessas**:
    - Para acessar os dados da promessa, podemos usar:
        - O método `.then()` para manipulação assíncrona.
        - O `await`, que deve estar dentro de uma função marcada como `async`.
    - Um exemplo foi fornecido de como retornar os dados de `obterDados` usando `await` em uma nova função.

4. **Exemplo de Retorno**:
    - Ao modificar o retorno da função para incluir uma string, observou-se que ainda retornava uma promessa, demonstrando que o `async` sempre embrulha o retorno em uma promessa.

5. **Revisão da Aula**:
    - O retorno de funções `async` é sempre encapsulado em promessas, que podem ser manipuladas usando `then` ou `await`.
    - Para o uso de `await`, é necessário estar dentro de uma função `async`.
    - O bloco `try-catch` pode ser usado para tratar erros em funções `async`, oferecendo um método alternativo ao `then` e `catch`.

## Conclusão

A aula forneceu uma introdução ao uso de `async` e `await` em JavaScript, destacando como elas simplificam o tratamento de operações assíncronas em comparação com o uso de promessas tradicionais. Esperamos que os alunos tenham gostado e estejam prontos para aplicar esses conceitos.

Estamos de volta, vamos continuar aqui, aprender sobre SYNC O8.
Nesta aula a gente vai só, ah, uma olhada no que acontece quando a gente retona, valores
da função normal da função A5.
Deixa eu limpar aqui esse console aqui do Firefox.
Ah, então vamos fazer uma função, por exemplo, obter dados.
Essa função obter dados vai retornar uma lista de objetos dessa maneira aqui.
Não importa muito o que são, só vou adicionar três objetos.
Cada objeto é uma propriedade chamada ID.
Não vai importar muito, o que importa é que a gente vai aprender sobre o valor retornado.
Então dessa maneira se definir se obter dados, se chamar obter dados, que a gente espera que
vai ser retornado.
Corretamente a lista com os três objetos, faz sentido, não é?
Mas agora o que acontece se a gente adicionar a palavra chave A5 antes da função obter
dados?
Vamos transformar essa função obter dados, vamos chamar obter dados dois, certo?
Oter dados dois.
Vamos transformar essa função na função sincrona, A5.
Desculpa, dessa maneira aqui, vamos ver no que dá.
Está aí, definir a função nesse caso, com a palavra A5.
Agora vou chamar obter dados, esqueci de dois, desculpa, vamos obter dados mesmo, vai dessa
maneira mesmo.
Vou chamar, olha aí no que dá.
Para retornar, o valor retornado foi uma promessa, não foi o objeto.
Então esse é um detalhe da função A5, se você retornar alguma coisa aqui, algum
valor da função A5, esse valor aqui automaticamente vai ser embrulhado numa promessa, que vai
ser realizada na mesma hora nesse caso.
Você note que você dá um olhado no objeto promise, o estado vai ser fulfilled, realizada
e o valor vai ser aquela caladista dos três objetos.
Certo então, para poder realmente pegar esses caras, você tem que fazer um das maneiras
de fazer isso, usando aquele velho DEN, dados, aí faz o que quiser, consola o dados, por
exemplo.
Essa é uma maneira, ou você pode usar o await, obter dados, dessa maneira, mas neste
caso vai ter problema porque quando a gente está aqui no console, a gente não está
dentro de uma função de A5.
Então para poder usar o await, sempre tem que ter o quê?
Tem que estar dentro de uma função A5, então tem que dar o A5, vamos obter dados,
por exemplo, fazer outra função só para fazer o A5 aqui, para poder chamar o await.
Então você dá o await, só pode dar dentro da função A5.
Aí você põe os dados aqui dentro de uma variável, aí vamos dar o console log, aí
vamos chamar a função, porque aqui a gente só definiu, não executou.
Aí vamos obter dados, chamou e retornou aqui no console log, deu o console log aqui,
olha aqui, listo.
Certo?
Esse valor aqui que você está vendo aqui é o valor retornado, você está vendo essa
seta aqui, é porque a gente não retornou nada explicitamente, por isso que apareceu
um negócio aqui da promessa, mas se eu tivesse definido aqui, olha aqui, com return, sei lá,
um string A, olha no que dá.
Vamos chamar o await dados de novo, deixa eu...
A.
Cadê?
Vamos obter dados.
Cadê?
Não pegou.
Está novamente, é 5 points, vamos obter dados, deu o console log, deixa eu só comentar aqui,
para ver no que dá, retorno A.
Vamos obter dados.
Retornou a promessa, a gente quer dar um dedo aqui, valor, console log, valor, está retornando
lá, isso é.
Então, está funcionando mesmo, porque a gente não tinha explicitamente retornado e sempre
retornou a promessa da função A5, não é?
Em qualquer caso, vamos revisar o que a gente fez aqui.
Então, nessa aula, a gente aprendeu que o que acontece quando a gente adiciona a palavra
chave A5 antes de definir a função, aquilo que for retornado se torna uma promessa sempre
retornado a função A5, que você tem que lidar usando seja o then ou o await, mas o await
sempre tem que estar dentro do queiro, uma função que é A5, não se esqueça disso,
certo?
Então, por essa aula é só a J5 await, uma introdução, e você pode tentar usar o A5 await
ao invés de usar o then, o await também, se você quiser aprender mais, você vai ver
que em vez de, quando você tiver aquele catch block, tem o then e tem o catch, o catch,
você pode usar o try and catch dentro da função A5, que ele vai ser rejeitado automaticamente
retornado pela função A5, a função A5 retorna a promessa com um valor rejeitado,
se você usar o try catch, o block de try catch dentro da função A5, isso é um mais avançado,
mas essa aula só foi para a introdução do A5 await, certo?
Então, espero que tenham gostado e até a próxima.
Muito obrigado.


000a-03 O Valor Retornado Pela Função Async no JavaScript

Promessas Rejeitadas, Blocos de Try Catch com Async Await no JavaScript

```markdown
# 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!
```

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.
