# Async/Await

No capítulo de promises, foi mostrado como uma promise funciona:

```javascript
const fsPromises= require('fsPromises')

// Ler o conteudo do arquivo `chave-privada.txt`
const promessaDaLeitura = fsPromises.readFile('./chave-privada.txt');

promessaDaLeitura.then((data) => {
  // Quando a leitura terminar, rodar essa função aqui
  console.log(data); // a chave privada
});

// Tanto faz chamar o then direto da função ou depois (guardando o retorno da função em uma variavel)
// fsPromises.readFile('./chave-privada.txt').then((data) => {
//  console.log(data);
// })
```

No exemplo acima, só há uma promise (marcado pelo ".then"), mas e se precisássemos utilizar a variável data em uma outra próxima promise?

Isso criaria um encadeamento de promises uma dentro da outra, e, no final, teríamos infinitas promises uma dentro da outra.

Algo como:

```javascript
f1.then((data1) => {
    f2(data1).then((data2) => {
        f3.then((data3) => {
            console.log(data3)
            //podendo continuar indefinidamente
        })
    })
})
```

Para o código acima, dá-se o nome de **callback hell**.

E como podemos evitar isso? Usando **async/await**!

O que acontece com uma função marcada com async/await é que ela espera a promise ser terminada antes de continuar o código, exatamente como o .then, mas sem entrar nos problemas de chaining.

A única coisa que precisamos fazer é o seguinte:

```javascript
const functionOne = async () => {
    const resultado = await functionTwo();
    const resultado2 = await functionThree(resultado) 
    
    console.log(resultado2)
}
```

Nesse exemplo, a função *functionOne* foi marcada para ser uma função "async" (assíncrona), e, dessa forma, qualquer função chamada com o "await" dentro dela irá fazer com que a *functionOne* espere (tradução de *await*) até que essa outra função (por exemplo, a *functionTwo*) termine sua operação assíncrona e retorne seu valor final para que a função-pai (*functionOne*) continue a sua execução. 

Então se, por exemplo, a *functionTwo* for uma função que lê um determinado arquivo, a *functionOne* irá ficar parada naquela linha, esperando até que a *functionTwo* termine a sua execução e retorne o que tiver de retornar, antes de prosseguir para a próxima linha de código.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://uclsanca.gitbook.io/learn/web-basico/javascript/async-await.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.