Aller au contenu
YouTurkey Tech
Tous les sujets JavaScript

Callback Hell

Intermédiaire

Pourquoi des étapes qui attendent chacune la précédente s'imbriquent de plus en plus, et pourquoi cela fait mal.S'appuie sur Higher-Order Functions

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 le callback hell en JavaScript ?

          Un callback est une fonction qu'on confie à une autre fonction pour qu'elle l'exécute plus tard. Quand plusieurs étapes asynchrones dépendent chacune de la précédente, chaque étape suivante doit être écrite dans le callback de la précédente. Le code dérive vers la droite à chaque niveau : c'est le , ou pyramide infernale.

          Pourquoi les callbacks imbriqués deviennent-ils difficiles à suivre ?

          • Une fonction asynchrone ne peut pas renvoyer son résultat ; elle peut seulement vous rappeler avec.
          • « Faire B après A » veut donc dire « mettre B dans le callback de A », et « puis C », un niveau plus bas.
          • Un seul try…catch autour de l'ensemble ne capture pas les erreurs, car chaque callback s'exécute plus tard, seul. Chaque niveau doit vérifier sa propre erreur.
          • Vous perdez le contrôle : la fonction qui reçoit le callback décide quand, et combien de fois, il s'exécute.

          Quelles erreurs fait-on souvent avec les callbacks ?

          Mini-exemple

          getUser(1, (error, user) => {  if (error) return console.error(error);  getOrders(user.id, (error, orders) => {    if (error) return console.error(error);    getDetails(orders[0], (error, details) => {      if (error) return console.error(error);      console.log(details);    });  });});

          Test rapide

          Dans const user = getUser(1, callback), où l’utilisateur est-il disponible ?

          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:

            Trois étapes doivent se suivre : charger l'utilisateur, puis ses commandes, puis le détail d'une commande. Chacune prend une seconde.

          2. Étape 2:

            start s'affiche aussitôt.

            Ligne 1

          3. Étape 3:

            Le premier setTimeout confie son callback au minuteur du navigateur. Les étapes 2 et 3 sont écrites dedans, car elles ne peuvent commencer qu'après l'étape 1.

            Lignes 3–11

          4. Étape 4:

            Le script n'attend pas : end s'affiche ensuite.

            Ligne 13

          5. Étape 5:

            Le script est terminé et la pile d'appels est vide. Tout le reste attend maintenant le minuteur.

          6. Étape 6:

            Une seconde plus tard, le premier callback passe dans la file des tâches, puis sur la pile d'appels vide.

            Lignes 3–11

          7. Étape 7:

            L'étape 1 affiche 1. user loaded.

            Ligne 4

          8. Étape 8:

            L'étape 2 a besoin de l'utilisateur : son setTimeout vit donc dans l'étape 1. Son callback part au minuteur, un niveau plus bas.

            Lignes 5–10

          9. Étape 9:

            Le premier callback se termine. La pile est de nouveau vide.

            Ligne 11

          10. Étape 10:

            Une seconde plus tard, le callback des commandes passe par la file des tâches et arrive sur la pile.

            Lignes 5–10

          11. Étape 11:

            L'étape 2 affiche 2. orders loaded.

            Ligne 6

          12. Étape 12:

            L'étape 3 est imbriquée encore un niveau plus bas. Chaque étape qui attend ajoute un niveau d'indentation.

            Lignes 7–9

          13. Étape 13:

            Le callback des commandes se termine.

            Ligne 10

          14. Étape 14:

            Une seconde de plus, et le callback du détail arrive sur la pile.

            Lignes 7–9

          15. Étape 15:

            L'étape 3 affiche 3. details loaded.

            Ligne 8

          16. Étape 16:

            Le dernier callback se termine. Les trois étapes se sont exécutées dans l'ordre, à une seconde d'intervalle.

            Ligne 9

          17. Étape 17:

            Ça marche, mais le code dérive vers la droite en pyramide. Ajoutez la gestion d'erreurs à chaque niveau et il devient illisible. Les promesses l'aplatissent.

            Lignes 3–11