Aller au contenu
YouTurkey Tech
Tous les sujets JavaScript

Event Loop

Intermédiaire

Pourquoi setTimeout(…, 0) s'exécute quand même après le reste du code, et où se placent les promesses.S'appuie sur Synchronous vs Asynchronous

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/17Appuyez sur Lecture, ou avancez pas à pas avec les flèches, pour commencer.
          Étape 0 sur 17

          Explication

          Lecture : 2 min

          Sur cette page

          Qu'est-ce que la boucle d'événements en JavaScript ?

          JavaScript s'exécute sur un seul fil : une seule pile d'appels, une seule chose à la fois. Les tâches lentes, comme les minuteurs, les requêtes réseau et les événements utilisateur, sont confiées à l'environnement (les Web APIs du navigateur, ou Node.js). Quand elles se terminent, leur callback attend dans une file. La décide quand chaque callback en attente peut s'exécuter.

          Comment la boucle d'événements choisit-elle ce qui s'exécute ensuite ?

          Les callbacks attendent dans l'une de deux files :

          • La file des microtâches : les callbacks des promesses (then, catch, finally) et le code qui suit un await.
          • La file des tâches, aussi appelée file des macrotâches ou des callbacks : minuteurs, événements et entrées-sorties.

          La boucle répète une seule règle :

          1. Exécuter la tâche courante jusqu'à ce que la pile d'appels soit vide.
          2. Exécuter toutes les microtâches, y compris celles ajoutées en chemin.
          3. Prendre la tâche suivante dans la file des tâches et recommencer.

          Les microtâches passent toujours avant la tâche suivante. C'est pourquoi une promesse résolue passe avant setTimeout(…, 0).

          Quelles erreurs fait-on souvent avec la boucle d'événements ?

          Mini-exemple

          setTimeout(() => console.log('task'), 0);Promise.resolve().then(() => console.log('microtask'));console.log('sync'); // sync// microtask// task

          Test rapide

          Dans quel ordre le mini-exemple affiche-t-il ses lignes ?

          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 entier s'exécute comme une seule tâche. Il est placé sur la pile d'appels et s'exécute de façon synchrone, de haut en bas.

          2. Étape 2:

            console.log('start') s'exécute immédiatement et affiche start.

            Ligne 1

          3. Étape 3:

            setTimeout est appelée et se place en haut de la pile d'appels.

            Lignes 3–5

          4. Étape 4:

            setTimeout confie le callback au minuteur du navigateur, une Web API, et rend la main aussitôt. Le script n'attend pas.

            Lignes 3–5

          5. Étape 5:

            Le minuteur de 0 ms est écoulé : le callback passe dans la file des tâches. Il doit y attendre que la pile d'appels soit vide.

            Lignes 3–5

          6. Étape 6:

            Promise.resolve() donne une promesse déjà résolue, sur laquelle .then est appelée.

            Ligne 7

          7. Étape 7:

            Comme la promesse est déjà résolue, .then met aussitôt son callback dans la file des microtâches.

            Lignes 7–9

          8. Étape 8:

            console.log('end') affiche end. Les deux callbacks attendent toujours.

            Ligne 11

          9. Étape 9:

            La tâche du script est terminée et la pile d'appels est vide. Avant toute autre chose, la boucle d'événements vide la file des microtâches.

          10. Étape 10:

            Le callback de la promesse passe sur la pile d'appels.

            Lignes 7–9

          11. Étape 11:

            Il affiche promise.

            Ligne 8

          12. Étape 12:

            Le callback se termine. La file des microtâches est désormais vide.

            Ligne 9

          13. Étape 13:

            C'est seulement maintenant que la boucle d'événements prend la tâche suivante dans la file des tâches.

          14. Étape 14:

            Le callback du minuteur passe enfin sur la pile d'appels.

            Lignes 3–5

          15. Étape 15:

            Il affiche timeout.

            Ligne 4

          16. Étape 16:

            Le callback se termine. La pile et les deux files étant vides, la boucle d'événements attend du travail.

            Ligne 5

          17. Étape 17:

            La sortie est start, end, promise, timeout : d'abord le code synchrone, puis les microtâches, puis les tâches.