> For the complete documentation index, see [llms.txt](https://uclsanca.gitbook.io/learn/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://uclsanca.gitbook.io/learn/web-basico/javascript/async-await.md).

# 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.