Tutoriel de promesse Node.js

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 avec les promesses, revenons d'abord sur ce que sont les fonctions de « rappel » dans Node.js. Nous avons beaucoup vu ces fonctions de rappel dans les chapitres précédents, passons donc 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.

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 ».

Remarque : 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.

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 modifierons ensuite notre code comme indiqué ci-dessous, qui met à jour un Employeename dans la collection 'Employee' en utilisant des promesses.

Étape 1) Installation des modules NPM

Pour utiliser Promises depuis une application Node JS, le module de promesse est requis. Pour installer le module de promesse, exécutez la commande ci-dessous

promesse d'installation npm

Étape 2) Modifier le code pour inclure des promesses

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"
            }
        });
    }); 

Explication du code : -

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 garantit que vous êtes connecté à la base de données EmployeeDb. La deuxième instruction recherche l'enregistrement portant 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.

(Notes: 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.

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"
        })
    })
});

Explication du code : -

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 2^nd 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 base de données, vous trouverez les 2 enregistrements insérés dans la MongoDB base de données.

Créer une promesse personnalisée

Une promesse personnalisée peut être créée à l'aide d'un module de nœud appelé « q ». La bibliothèque 'q' doit être téléchargée et installée à l'aide du gestionnaire de packages de nœuds. Après avoir utilisé la bibliothèque 'q', la méthode « denodeify » peut être appelée, ce qui fera que n'importe quelle fonction deviendra une fonction qui renvoie 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 « q » depuis 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.

Explication du code : -

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édéifier (la méthode utilisée pour convertir n'importe quelle fonction en fonction qui renverrait une promesse) notre fonction Add ou autrement 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, affichez la chaîne « Fonction d'ajout terminée » dans le 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.

Résumé

• L'utilisation de fonctions de rappel dans Node.js présente des inconvénients. Parfois, au cours du processus de développement, l'utilisation imbriquée de fonctions de rappel peut rendre le code plus compliqué et difficile à maintenir.
• La plupart des problèmes liés aux fonctions de rappel imbriquées peuvent être atténués grâce à l'utilisation de promesses et de générateurs dans node.js
• Une Promesse est une valeur renvoyée par une fonction asynchrone pour indiquer la fin du traitement effectué par la fonction asynchrone.
• Les promesses peuvent être imbriquées les unes dans les autres pour rendre le code plus beau et plus facile à maintenir lorsqu'une fonction asynchrone doit être appelée après une autre fonction asynchrone.