Comment fonctionne le Async / Await en javascript ?
Tags: french, javascript, beginners, tutorial
Published: 2021-06-25 13:58:01

---
title: Comment fonctionne le Async / Await en javascript ?
published: true
description: 
tags: french, javascript, beginner, tutorial
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ik1c8mr2sz8zi3g466dq.jpg
---
Si vous désirez plus de contenu francophone comme celui-ci, cliquer <strong>Follow<string> ou <a href="https://twitter.com/EricLeCodeur" class="twitter-follow-button">suivez-moi sur Twitter</a>
<hr>
<h2>Synchrone vs Asynchrone</h2>
Le code <b>synchrone</b> est exécuté ligne par ligne. Chaque ligne de code attend toujours la fin de la ligne précédente avant d'exécuter la suivante. Alors évidemment, le problème est qu'une opération longue durée bloquera l'exécution du code.

Le code <b>asynchrone</b> quant à lui n'est pas bloquant, alors il n'attend pas la fin d'une autre tâche.

Un exemple d'asynchrone en javascript est la fonction fetch() Fetch) permet d'obtenir des données (généralement en format JSON) à un serveur web de manière dynamique (sans bloqué l'exécution du code et sans recharger la page)

Une fonction asynchrone moderne comme fetch() renvoie une promesse. aka, un conteneur/espace réservé pour un résultat futur. Le futur résultat/valeur est la réponse de l'appel fetch.
```js
// Exemple d'une fonction fetch() renvoyant une promesse
const request = fetch('http://example.com/api/cats')

// Retourne une promesse
console.log(request) // Promise {<pending>}
```

Une promesse est en attente jusqu'à ce qu'elle soit réglée (terminé). Il peut avoir deux statuts réglés : accompli (succès) ou rejeté (erreur).

```js
// Exemple d'une fonction fetch() renvoyant une promesse
const getCatsImage = function() {
  // La fonction fetch() renvoie une promesse
  // Lorsque la promesse est remplie, la fonction s'exécute
  // Le résultat est contenu dans le paramètre data
  const request = fetch('http://example.com/api/cats')
    .then(response => return response.json())
    .then(data => loadCatImage(data[0]))
  })
}
``` 

Gestion des erreurs
```js
const getCatsImage = function() {
  // La fonction fetch() renvoie une promesse
  // Lorsque la promesse est remplie, la fonction s'exécute
  // Le résultat est contenu dans le paramètre data
  // Si y il a erreur la fonction catch() va s'éxécuter
  // La fonction finally() s'éxécute dans tous les cas
  const request = fetch('http://example.com/api/cats')
    .then(response => return response.json())
    .then(data => loadCatImage(data[0]))
    .catch(err => console.log(err))
    .finally(() => console.log('Run after both')
  })
}
```

Créer une promesse
```js
const wait = function(sec) {
  return new Promise(function(resolve, reject) {
    setTimeout(() => {
      resolve('wait over')
    }, sec * 1000)
  })
}

wait(3).then((msg) => console.log(msg)) // wait over
```


*Async / Await*
La fonction async et le mot-clé await ont été introduits comme une extension des promesses. Ils ont été introduits pour rendre la programmation asynchrone basée sur des promesses plus lisible. Async/await simplifie simplement la syntaxe utilisée pour consommer une promesse.

```js
// Async exécute la fonction en mode asynchrone
// et retourne une promesse
const delay = async function(sec) {
  // Await met en pause le bloc de fonction asynchrone du code
  // jusqu'à ce que la promesse retourne un résultat
  const response = await new Promise(function(resolve, reject) {
     setTimeout(() => {
      resolve('wait over')
    }, sec * 1000)
  })
  console.log(response)
}

delay(3)
```
Catch error in async/await
```js
const delay = async function(sec) {
  try {
    const response = await new Promise(function(resolve, reject) {
      setTimeout(() => {
        resolve('wait over')
      }, sec * 1000)
    })
    console.log(response)
  } catch(err) {
    console.log(err.message)
    // You can also throw error up to calling parent
    throw err
  }
}
delay(3)

```
Le mot-clé await ne peut être utilisé que dans une fonction Async. Donc, pour utiliser await dans le module principal, vous devez créer un IIFE (fonction immédiatement invoquée)
```js
(async function() {
  const cats = await getCats()
  console.log('start')
  console.log(cats)
  console.log('end')
})()
```
Même concept mais avec l'opérateur then()
```js
console.log('start')
getCats().then(cats => {
    console.log(cats)
    console.log('end')
}
```

Exécuter des promesses en parallèle
```js
(async function() {
  // const cats = await getCats()
  // const dogs = await getDogs()
  // utiliser Promise.all pour exécution en parallèle
  const data = await Promise.all([getCats(), getDogs()])
  console.log('start')
  // Promise.All returne un tableau
  console.log(data[0]) //cats
  console.log(data[1]) //dogs
  console.log('end')
})()
```