Apprendre le JavaScript : Promise

Les promesses représentent une notion cruciale en JavaScript pour gérer l'asynchronisme, offrant une alternative aux structures imbriquées de callbacks qui rendent le code difficilement maintenable sur le long terme. Ces objets permettent de représenter l'état futur d'une opération asynchrone. L'utilisation de ces mécanismes est essentielle pour écrire du code JavaScript moderne et pérenne, s'éloignant des enchaînements complexes de fonctions de rappel.

Pour utiliser une promesse, il faut créer une nouvelle instance de l'objet `Promise`. Le constructeur attend une fonction exécutrice possédant deux paramètres : `resolve` et `reject`. La fonction `resolve` est appelée lorsque l'opération réussit et que la promesse est tenue. Inversement, si l'opération ne peut être menée à terme, la méthode `reject` est invoquée pour signaler l'échec avec une valeur explicative.

Pour savoir si une promesse a été résolue ou non dans la suite du script, deux méthodes principales sont disponibles. La méthode `.then()` accepte un callback qui sera exécuté avec les valeurs renvoyées lors de la résolution. Pour capturer un échec, la méthode `.catch()` est employée, fonctionnant sur un principe similaire à la structure `try/catch` habituelle.

Cela n'a pas l'air de résoudre le problème des callbacks parce que finalement il y a un callback.

L'avantage du chaînage réside dans la possibilité de retourner une valeur ou une nouvelle promesse depuis un bloc `.then()`. Si une valeur est retournée, elle devient le résultat résolu de la promesse suivante dans la chaîne. Si une nouvelle promesse est retournée, la chaîne attendra la résolution de cette dernière avant de passer au gestionnaire suivant.

Un élément de syntaxe plus récent permet de travailler avec les promesses de manière beaucoup plus simple que l'enchaînement des méthodes `.then()` et `.catch()`. Il est possible de déclarer une fonction comme asynchrone en utilisant le mot-clé `async`. Cette modification impacte la manière dont la fonction retourne son résultat, même si elle ne contient pas d'opérations asynchrones explicites.

Lorsqu'une fonction est déclarée `async`, si elle retourne une valeur directement, cette valeur est automatiquement encapsulée dans une promesse résolue. Inversement, si une erreur est lancée à l'intérieur, la fonction retourne une promesse rejetée avec l'erreur correspondante, modifiant ainsi la gestion des résultats.

Le mot-clé `await` est l'outil super intéressant qui permet de suspendre l'exécution du code dans une fonction `async` jusqu'à ce que la promesse qui lui est passée soit résolue. Cela permet de structurer le code de façon séquentielle, le rendant beaucoup plus facile à lire et à comprendre que les callbacks imbriqués.

Lorsque l'opérateur `await` est utilisé sur une promesse qui se résout, la valeur de résolution est directement assignée à la variable qui précède `await`. Cela permet de stocker le résultat attendu pour une utilisation immédiate dans les lignes de code suivantes, assurant une lecture de haut en bas.

Il existe plusieurs méthodes sur l'objet `Promise` permettant de combiner plusieurs opérations asynchrones en une seule entité gérable. Ces outils sont particulièrement utiles lorsque plusieurs tâches doivent être lancées simultanément, mais leur gestion dépend du comportement souhaité en cas de succès ou d'échec des sous-opérations.

`Promise.resolve(value)` et `Promise.reject(value)` sont des utilitaires simples qui renvoient directement une promesse déjà dans l'état souhaité. Ceci est nécessaire lorsque certains algorithmes ou fonctions attendent un objet promesse plutôt qu'une valeur classique.

`Promise.all` prend un itérable de promesses et renvoie une nouvelle promesse qui se résout avec un tableau contenant les résultats de toutes les promesses si elles réussissent toutes. Si une seule promesse échoue, `Promise.all` rejette immédiatement avec l'erreur de cette promesse défaillante.

`Promise.allSettled` fonctionne de manière similaire à `all` mais ignore les rejets. Il attend que toutes les promesses soient terminées, réussies ou non. Le résultat est un tableau d'objets indiquant le statut (`fulfilled` ou `rejected`) et la valeur ou la raison associée à chaque promesse.

La méthode `Promise.any` résout dès que la première promesse réussit, ignorant les échecs initiaux jusqu'à ce qu'une réussite soit obtenue. En revanche, `Promise.race` résout ou rejette dès que la première promesse se termine, qu'elle réussisse ou échoue, se basant uniquement sur la rapidité d'achèvement.

Une distinction fondamentale doit être faite concernant l'exécution du code dans une promesse. Le code contenu dans le corps de la fonction exécutrice passée à `new Promise()` est exécuté immédiatement lors de l'instanciation de l'objet. Ce n'est pas l'appel à `.then()` qui déclenche ce code, mais sa simple création.

Le fil principal exécute cette fonction tout de suite [...] ensuite il voit que c'est du code asynchrone donc le .then il se le met en attente.

Le moteur JavaScript privilégie toujours l'exécution du fil principal. Les callbacks associés aux promesses, même si la promesse se résout instantanément, sont mis en file d'attente. Ils ne sont appelés qu'une fois que le fil principal a terminé son exécution, assurant ainsi que l'asynchronisme est correctement géré après le code synchrone.

L'utilisation du mot-clé `async` est spécifiquement recommandée lorsqu'il y a un besoin d'utiliser `await` à l'intérieur de la fonction pour lire le code de manière séquentielle. Déclarer une fonction `async` sans utiliser `await` crée inutilement une nouvelle promesse autour du retour, ce qui représente une perte de performance sans bénéfice fonctionnel.