Tutoriel de promesse Node.js

⚡ Résumé intelligent

Dans Node.js, les promesses remplacent les rappels profondément imbriqués par un objet renvoyé qui se stabilise une seule fois, de sorte que le travail asynchrone sur la base de données se lit comme une chaîne plate de clauses « then » au lieu d'une pyramide de fonctions anonymes.

  • (I.e. Problème de rappel : Les fonctions de rappel imbriquées deviennent longues et difficiles à maintenir.
  • ☑️ Principes de base de la promesse : Une promesse renvoie une valeur et se règle une seule fois.
  • Enchaînement : puis elle-même renvoie une promesse, donc les insertions s'exécutent dans l'ordre.
  • 🧪 Promesses personnalisées : La bibliothèque q denodeify encapsule n'importe quel rappel.
  • Forme moderne : async et await consomment des promesses sans fonctions de rappel.
  • (I.e. Règle d'erreur : Les rejets non gérés entraînent l'arrêt de Node.js depuis la version 15.

Tutoriel sur les promesses Node.js montrant comment chaîner des fonctions de rappel dans des promesses

Dans les didacticiels précédents, vous auriez vu des fonctions de rappel utilisées pour les événements asynchrones. Mais parfois, les fonctions de rappel peuvent devenir un cauchemar lorsqu'elles commencent à s'imbriquer et que le programme commence à devenir long et complexe.

Que sont les promesses ?

Avant de commencer par les promesses, revenons d'abord sur ce que sont les fonctions de « rappel » dans Node.jsNous avons beaucoup vu ces fonctions de rappel dans les chapitres précédents, alors passons rapidement en revue l'une d'entre elles.

L'exemple ci-dessous montre un extrait de code utilisé pour se connecter à un MongoDB base de données et effectuer une opération de mise à jour sur l'un des enregistrements de la base de données.

Fonction de rappel Node.js se connectant à MongoDB et la mise à jour d'un enregistrement

  1. Dans le code ci-dessus, la partie de la fonction (err, db) est connue sous le nom de déclaration d'une fonction anonyme ou de rappel. Lorsque le MongoClient crée une connexion au MongoDB base de données, il reviendra à la fonction de rappel une fois l'opération de connexion terminée. Donc, dans un sens, les opérations de connexion se déroulent en arrière-plan, et lorsqu'elles sont terminées, elles appellent notre fonction de rappel. N'oubliez pas que c'est l'un des points clés de Node.js pour permettre à de nombreuses opérations de se produire simultanément et ainsi ne bloquer aucun utilisateur pour effectuer une opération.
  2. Le deuxième bloc de code est ce qui est exécuté lorsque la fonction de rappel est réellement appelée. La fonction de rappel met simplement à jour un enregistrement dans notre MongoDB base de données.

Alors, qu’est-ce qu’une promesse ? Eh bien, une promesse n'est qu'une amélioration des fonctions de rappel dans Node.js. Au cours du cycle de vie de développement, il peut arriver que vous deviez imbriquer plusieurs fonctions de rappel ensemble. Cela peut devenir un peu compliqué et difficile à maintenir à un moment donné. En bref, une promesse est une amélioration des rappels qui vise à atténuer ces problèmes.

La syntaxe de base d'une promesse est présentée ci-dessous ;

var promise = doSomethingAync()
promise.then(onFulfilled, onRejected)
  • "doSomethingAync" est n'importe quelle fonction de rappel ou asynchrone qui effectue une sorte de traitement.
  • Cette fois, lors de la définition du rappel, une valeur est renvoyée appelée « promesse ».
  • Lorsqu'une promesse est renvoyée, elle peut avoir 2 sorties. Ceci est défini par la « clause then ». Soit l'opération peut être un succès, ce qui est indiqué par le paramètre « onFulfilled ». Ou il peut y avoir une erreur indiquée par le paramètre « onRejected ».

A PROMETTONS se situe dans l'un des trois États et s'y installe une fois :

État Sens
En Attente Les travaux ne sont pas terminés.
Réalisé la fonction onFulfilled s'exécute avec la valeur.
Rejeté La fonction onRejected s'exécute avec l'erreur.

À noter: L’aspect clé d’une promesse est donc la valeur de retour. Il n'y a aucun concept de valeur de retour lorsque vous travaillez avec des rappels normaux dans Node.js. Grâce à la valeur de retour, nous avons plus de contrôle sur la façon dont la fonction de rappel peut être définie.

Note de version : Ces exemples fonctionnent toujours avec Node.js 24, la branche LTS active en 2026. Depuis Node.js 15, rejet non géré interrompt le processus au lieu d'afficher un avertissement, fermez donc chaque chaîne avec .catch().

Dans la rubrique suivante, nous verrons un exemple de promesses et comment elles bénéficient des rappels.

Rappels aux promesses

Examinons maintenant un exemple de la façon dont nous pouvons utiliser les « promesses » à partir d'une application Node.js. Afin d'utiliser les promesses dans une application Node.js, le module 'promise' doit d'abord être téléchargé et installé.

Nous allons ensuite modifier notre code comme indiqué ci-dessous, qui met à jour un EmployeeName dans la collection 'Employee' en utilisant des promesses.

Étape 1) Installation du Modules NPM

Pour utiliser les promesses dans une application Node.js, le module `promise` est requis. Pour installer ce module, exécutez la commande ci-dessous.

promesse d'installation npm

Étape 2) Modifier le code pour inclure des promesses

Capture d'écran de l'éditeur montrant le module de promesse réécrivant la MongoDB Mise à jour

var Promise = require('promise');
var MongoClient = require('mongodb').MongoClient;
var url = 'mongodb://localhost/EmployeeDB';

MongoClient.connect(url)
    .then(function(err, db) {
        db.collection('Employee').updateOne({
            "EmployeeName": "Martin"
        }, {
            $set: {
                "EmployeeName": "Mohan"
            }
        });
    }); 

Code Explication:

  1. La première partie consiste à inclure le module 'promise' qui nous permettra d'utiliser la fonctionnalité de promesse dans notre code.
  2. Nous pouvons maintenant ajouter la fonction « alors » à notre fonction MongoClient.connect. Cela fait donc que lorsque la connexion est établie à la base de données, nous devons exécuter l'extrait de code défini par la suite.
  3. Enfin, nous définissons notre extrait de code qui effectue le travail de mise à jour EmployeeName de l'employé portant le nom de « Martin » en « Mohan ».

Remarque:

Si vous vérifiez maintenant le contenu de votre MongoDB base de données, vous constaterez que si un enregistrement avec EmployeeName de « Martin » existe, il sera mis à jour en « Mohan ».

Pour vérifier que les données ont été correctement insérées dans la base de données, vous devez exécuter les commandes suivantes dans MongoDB

  1. utiliser EmployeeDB
  2. db.Employee.find({EmployeeName : “Mohan”})

La première instruction vérifie que vous êtes bien connecté à la base de données EmployeeDB. La seconde instruction recherche l'enregistrement contenant le nom d'employé « Mohan ».

Gérer les promesses imbriquées

Lors de la définition des promesses, il convient de noter que la méthode « alors » elle-même renvoie une promesse. Ainsi, dans un sens, les promesses peuvent être imbriquées ou enchaînées les unes aux autres.

Dans l'exemple ci-dessous, nous utilisons le chaînage pour définir 2 fonctions de rappel, qui insèrent toutes deux un enregistrement dans le MongoDB base de données.

(Note: Le chaînage est un concept utilisé pour lier l'exécution de méthodes entre elles. Supposons que votre application dispose de 2 méthodes appelées « méthodeA » et « méthodeB ». Et la logique était telle que « méthodeB » devait être appelée après « méthodeA », puis vous enchaîneriez l'exécution de telle manière que « méthodeB » soit appelée directement après « méthodeA ».)

L'élément clé à noter dans cet exemple est que le code devient plus propre, lisible et maintenable grâce à l'utilisation de promesses imbriquées.

Des clauses « then » enchaînées insèrent deux enregistrements d'employés dans MongoDB

var Promise = require('promise');
var MongoClient = require('mongodb').MongoClient;
var url = 'mongodb://localhost/EmployeeDB';
MongoClient.connect(url)

.then(function(db) {
    db.collection('Employee').insertOne({
        Employeeid: 4,
        EmployeeName: "NewEmployee"
    })

    .then(function(db1) {
        db1.collection('Employee').insertOne({
            Employeeid: 5,
            EmployeeName: "NewEmployee1"
        })
    })
});

Code Explication:

  1. Nous définissons maintenant 2 clauses « then » qui s’exécutent l’une après l’autre. Dans la première clause then, nous transmettons le paramètre 'db' qui contient notre connexion à la base de données. Nous utilisons ensuite la propriété collection de la connexion 'db' pour insérer des enregistrements dans la collection 'Employee'. La méthode « insertOne » est utilisée pour insérer le document réel dans la collection Employee.
  2. On utilise alors le 2nd clause then également pour insérer un autre enregistrement dans la base de données.

Si vous vérifiez maintenant le contenu de votre MongoDB Dans la base de données, vous trouverez les 2 enregistrements insérés. MongoDB base de données.

Équivalent moderne : async et await, standards depuis ES2017, consomment ces promesses sans callbacks then et ont largement remplacé générateur Les bibliothèques de contrôle de flux telles que co, tandis que la prise en charge native des promesses rend q et bluebird superflues. Le deuxième bloc montre alors la réception uniquement de db.

Créer une promesse personnalisée

Il est possible de créer une promesse personnalisée grâce au module Node.js « q ». La bibliothèque « q » doit être téléchargée et installée via le gestionnaire de paquets Node (NPM). Une fois la bibliothèque « q » installée, la méthode « denodeify » permet de transformer n'importe quelle fonction en une fonction renvoyant une promesse.

Dans l'exemple ci-dessous, nous allons créer une fonction simple appelée « Ajouter » qui ajoutera 2 nombres. Nous allons convertir cette fonction en fonction pour renvoyer une promesse.

Une fois cela fait, nous utiliserons la promesse renvoyée par la fonction Add pour afficher un message dans le console.log.

Suivons les étapes ci-dessous pour créer notre fonction personnalisée afin de renvoyer une promesse.

Étape 1) Installation des modules NPM

Pour utiliser la commande « q » dans une application Node.js, le module « q » est requis. Pour installer le module « q », exécutez la commande ci-dessous.

npm installer q

Étape 2) Définissez le code suivant qui sera utilisé pour créer la promesse personnalisée.

promesse personnalisée construite par wrapping une fonction Add avec q dénodéifier

Code Explication:

  1. Le premier bit consiste à inclure la bibliothèque 'q' en utilisant le mot-clé require. En utilisant cette bibliothèque, nous pourrons définir n'importe quelle fonction pour renvoyer un rappel.
  2. Nous créons une fonction appelée Add qui ajoutera 2 nombres définis dans les variables a et b. La somme de ces valeurs sera stockée dans la variable c.
  3. Nous utilisons ensuite la bibliothèque q pour dénodéifier (la méthode utilisée pour convertir n'importe quelle fonction en une fonction qui renverrait une promesse) notre fonction Add, ou en d'autres termes, convertir notre fonction Add en une fonction qui renvoie une promesse.
  4. Nous appelons maintenant notre fonction « Ajouter » et sommes en mesure d'obtenir une valeur promise de retour grâce à l'étape précédente que nous avons effectuée pour dénodéifier la fonction Ajouter.
  5. Le mot-clé « then » est utilisé pour spécifier que si la fonction est exécutée avec succès, la chaîne « Fonction additionnelle terminée » s'affiche dans la console.log.

Lorsque le code ci-dessus est exécuté, la sortie « Fonction d'ajout terminée » sera affichée dans le console.log comme indiqué ci-dessous.

Affichage de la sortie console : Fonction d'addition terminée à partir de la promesse personnalisée

FAQ

Depuis Node.js 15, le processus se termine par un code d'erreur plutôt que par un avertissement. Ajoutez `.catch()` à chaque chaîne d'exécution, ou enregistrez un gestionnaire d'erreurs. gestionnaire de processus pour enregistrer et récupérer.

La méthode `catch()` intercepte toute erreur levée plus tôt dans la chaîne, à l'instar d'un bloc `try`. La méthode `finally()` exécute le code selon le résultat de la chaîne, ce qui la rend adaptée à la fermeture d'une connexion.

Promise.all échoue rapidement si une seule entrée est rejetée. allSettled résout toujours la promesse et signale chaque résultat. race adopte le premier résultat résolu. any nécessite au moins un succès, sinon une exception AggregateError est levée.

Les deux méthodes consomment la même promesse. `await` effectue une pause à l'intérieur d'une fonction asynchrone, de sorte que les résultats sont stockés dans des variables ordinaires et que les erreurs sont gérées par un bloc `try...catch`.

Rarement. Generator Les fonctions avec yield étaient autrefois le moteur de bibliothèques telles que co, mais async et await remplissent ce rôle nativement. Generators convient toujours aux séquences paresseuses et aux itérateurs personnalisés.

La fonction `util.promisify` convertit directement une fonction de type rappel, et des modules comme `fs.promises` renvoient déjà des promesses. Ces deux fonctions remplacent la bibliothèque `q` mentionnée précédemment.

Oui. Les analyseurs d'apprentissage automatique repèrent les chaînes sans gestionnaire de rejet, les attentes à l'intérieur des boucles et les écritures dépendantes de l'ordre, puis classent les résultats. tests emprunter les chemins les plus risqués.

Copilote GitHub et d'autres assistants similaires réécrivent rapidement les rappels imbriqués sous forme d'appels await, mais chaque réécriture nécessite une vérification en raison des chemins d'erreur et route La sémantique évolue silencieusement.

Résumez cet article avec :