Promises (JavaScript)

Les promesses en JavaScript, ou Promise, sont un élément essentiel pour gérer l'Asynchrone (programmation) dans le langage. En simplifiant, une promesse est un objet qui représente la complétion ou l'échec éventuel d'une opération Asynchrone (programmation).

Une promesse peut être dans l'un des trois états suivants :

1. Pending (en attente) : L'opération initiale n'a pas encore été complétée.
2. Fulfilled (accomplie) : L'opération s'est terminée avec succès.
3. Rejected (rejetée) : L'opération a échoué.

L'avantage d'utiliser des promesses est que tu peux chaîner les opérations asynchrones de manière plus lisible et gérer les erreurs plus efficacement. (cf Promise Chaining)

Voici un exemple en TypeScript pour te montrer comment créer et utiliser des promesses. Imaginons que tu veuilles simuler une opération asynchrone qui récupère des données après un délai.

function fetchData(): Promise<string> {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            try {
                const data = "Données récupérées"; // Simule la récupération des données.
                resolve(data); // Si tout va bien, on appelle resolve avec les données.
            } catch (error) {
                reject("Erreur lors de la récupération des données"); // En cas d'erreur, on appelle reject.
            }
        }, 2000); // Délai de 2 secondes pour simuler l'opération asynchrone.
    });
}

// Utilisation de la promesse
fetchData()
    .then(data => {
        console.log(data); // Traitement en cas de succès.
    })
    .catch(error => {
        console.error(error); // Gestion des erreurs.
    });

Dans cet exemple, fetchData est une fonction qui retourne une promesse. La promesse est créée avec le constructeur Promise qui prend une fonction exécuteur avec deux arguments, resolve et reject. Ces fonctions permettent de contrôler l'état de la promesse :

• resolve est appelée pour indiquer que la promesse est accomplie, passant les données de réussite.
• reject est appelée pour indiquer que la promesse est rejetée, passant les détails de l'erreur.

Après avoir appelé fetchData, tu utilises .then() pour spécifier quoi faire avec les données une fois qu'elles sont disponibles, et .catch() pour gérer les erreurs. C'est beaucoup plus propre et gérable comparé aux anciennes techniques de gestion d'asynchronisme comme les callbacks, surtout lorsque les opérations deviennent complexes.

Pour approfondir ta compréhension des promesses en JavaScript et élargir tes compétences en programmation asynchrone, voici une liste de notions et de fonctionnalités que tu pourrais explorer :

1. Async & Await : Une syntaxe plus moderne et élégante pour travailler avec des opérations asynchrones, utilisant des promesses sous le capot pour simplifier l'écriture de code asynchrone en le faisant ressembler à du code synchrone.

2. Promise.all et Promise.race : Utiliser ces méthodes pour orchestrer plusieurs promesses simultanément, soit en attendant que toutes se résolvent (Promise.all), soit en agissant dès que la première se résout (Promise.race).

3. Promise.allSettled : Une méthode pour attendre que toutes les promesses données se terminent, qu'elles soient résolues ou rejetées, ce qui est utile pour exécuter des tâches de nettoyage ou des résumés.

4. Promises et boucles d'événements (Event Loop) : Comprendre comment les promesses interagissent avec la boucle d'événements de JavaScript, ce qui est crucial pour saisir comment les opérations asynchrones sont planifiées et exécutées.

5. Microtasks et Macrotasks : Explorer la différence entre ces deux types de tâches dans la boucle d'événements, et comment elles affectent l'exécution du code asynchrone.

Ces sujets te permettront de maîtriser les aspects les plus avancés de la programmation asynchrone en JavaScript et d'améliorer la robustesse et l'efficacité de tes applications.