Aller au contenu
YouTurkey Tech
Tous les sujets JavaScript

Promises & async/await

Intermédiaire

Comment une promesse représente un résultat pas encore prêt, quand ses callbacks s'exécutent, et ce que await met vraiment en pause.S'appuie sur Callback Hell, Event Loop

Pile d'appels

Vide

    Web APIs

    Vide

      File des microtâches

      Vide

        File des tâches

        Vide

          Boucle d'événements
          1. Exécution du code
          2. Exécution des microtâches
          3. Prise de la tâche suivante
          4. En attente
          Console

          Vide

          0/20Appuyez sur Lecture, ou avancez pas à pas avec les flèches, pour commencer.
          Étape 0 sur 20

          Explication

          Lecture : 2 min

          Sur cette page

          Qu'est-ce qu'une promesse en JavaScript ?

          Une promesse est un objet qui représente un résultat pas encore prêt. Elle est dans l'un de trois états : (pending), tenue (fulfilled, avec une valeur) ou rompue (rejected, avec une erreur). Une fois réglée, elle ne change plus jamais.

          async/await est une syntaxe construite sur les promesses. Une fonction async renvoie toujours une promesse, et await met en pause cette fonction, et elle seule, jusqu'à ce qu'une promesse soit réglée.

          Comment s'exécutent les promesses et async/await ?

          • .then(fn) enregistre fn pour qu'elle reçoive la valeur une fois la promesse tenue ; .catch(fn) s'exécute en cas de rejet ; .finally(fn) dans les deux cas.
          • .then renvoie une nouvelle promesse : les étapes s'enchaînent à plat, l'une après l'autre, au lieu de s'imbriquer.
          • Les callbacks des promesses et le code qui suit un await s'exécutent comme des microtâches : après le code courant, avant le prochain minuteur ou événement.
          • Pour lancer des travaux indépendants en même temps, démarrez-les ensemble et combinez-les : Promise.all (tous doivent réussir), Promise.allSettled (attendre tous les résultats), Promise.race (le premier réglé) et Promise.any (le premier réussi).

          Quelles erreurs fait-on souvent avec les promesses ?

          Mini-exemple

          async function showUser(id) {  try {    const response = await fetch(`/api/users/${id}`);    const user = await response.json();    console.log(user.name);  } catch (error) {    console.error('Could not load the user', error);  }} const [a, b] = await Promise.all([fetch('/api/a'), fetch('/api/b')]);

          Test rapide

          Dans une fonction async, que met en pause await ?

          Pour aller plus loin

          Regarder la vidéo

          L’explication complète sur la chaîne YouTube YouTurkey Tech, en arabe.

          Toutes les étapes en texte
          1. Étape 1:

            Le script démarre sur la pile d'appels. wait et brew sont déclarées mais pas encore appelées.

          2. Étape 2:

            start s'affiche.

            Ligne 12

          3. Étape 3:

            brew() est appelée. Une fonction async s'exécute de façon synchrone jusqu'à son premier await.

            Ligne 13

          4. Étape 4:

            boiling water s'affiche.

            Ligne 6

          5. Étape 5:

            wait(1000) est appelée et se place en haut de la pile.

            Ligne 7

          6. Étape 6:

            new Promise exécute sa fonction tout de suite. Elle lance un minuteur qui appellera resolve dans 1000 ms.

            Ligne 2

          7. Étape 7:

            wait renvoie une promesse encore en attente (pending) : une place réservée pour un résultat pas encore prêt.

            Ligne 2

          8. Étape 8:

            await tombe sur une promesse en attente : brew se met en pause et quitte la pile. Elle rend à l'appelant sa propre promesse en attente.

            Ligne 7

          9. Étape 9:

            .then enregistre un callback sur la promesse de brew. Rien n'est mis en file : il ne s'exécutera qu'une fois cette promesse tenue.

            Ligne 13

          10. Étape 10:

            end s'affiche. await n'a mis en pause que brew, jamais le reste du script.

            Ligne 14

          11. Étape 11:

            Le script est terminé et la pile est vide. La boucle attend le minuteur.

          12. Étape 12:

            Au bout de 1000 ms, resolve passe par la file des tâches et arrive sur la pile.

            Ligne 2

          13. Étape 13:

            L'appel de resolve tient la promesse de wait. La suite de brew, après le await, est mise dans la file des microtâches.

            Lignes 2–7

          14. Étape 14:

            La pile est vide : les microtâches s'exécutent, et brew reprend exactement là où elle s'était arrêtée.

            Ligne 8

          15. Étape 15:

            coffee ready s'affiche.

            Ligne 8

          16. Étape 16:

            return 'coffee' tient la promesse de brew avec 'coffee' : le callback de .then entre dans la file des microtâches.

            Lignes 9–13

          17. Étape 17:

            La boucle vide encore les microtâches : le callback de .then s'exécute aussitôt, avec drink égal à 'coffee'.

            Ligne 13

          18. Étape 18:

            enjoy coffee s'affiche.

            Ligne 13

          19. Étape 19:

            Le callback se termine. La pile et les deux files sont vides.

            Ligne 13

          20. Étape 20:

            Sortie : start, boiling water, end, coffee ready, enjoy coffee. Aucune imbrication : chaque étape qui attend tient sur une ligne.