Node.js Promise-zelfstudie

In eerdere tutorials heb je callback-functies gezien die worden gebruikt voor asynchrone gebeurtenissen. Maar soms kunnen callback-functies een nachtmerrie worden wanneer ze genest raken en het programma lang en complex wordt.

Wat zijn beloften?

Voordat we met beloftes beginnen, gaan we eerst eens kijken naar de callback-functies in Node.js. We hebben deze callback-functies veel gezien in de voorgaande hoofdstukken, dus laten we er snel een doornemen.

In het onderstaande voorbeeld ziet u een codefragment dat wordt gebruikt om verbinding te maken met een MongoDB database en voer een updatebewerking uit op een van de records in de database.

1. In de bovenstaande code staat het deel van de functie (err,db) bekend als de declaratie van een anonieme of callback-functie. Wanneer de MongoClient een verbinding tot stand brengt met het MongoDB database, keert het terug naar de callback-functie zodra de verbindingsbewerking is voltooid. Dus in zekere zin gebeuren de verbindingsbewerkingen op de achtergrond en wanneer het klaar is, roept het onze callback-functie aan. Vergeet niet dat dit een van de belangrijkste punten van Node.js is om veel bewerkingen gelijktijdig te laten plaatsvinden en dus geen enkele gebruiker te blokkeren om een ​​bewerking uit te voeren.
2. Het tweede codeblok wordt uitgevoerd wanneer de callback-functie daadwerkelijk wordt aangeroepen. De callback-functie werkt slechts één record in onze MongoDB database.

Wat is dan een belofte? Welnu, een belofte is slechts een verbetering van de callback-functies in Node.js. Tijdens de ontwikkelingslevenscyclus kan het voorkomen dat u meerdere callback-functies samen moet nesten. Dit kan op een bepaald moment nogal rommelig en moeilijk te onderhouden worden. Kortom, een belofte is een verbetering van terugbelverzoeken die gericht is op het verlichten van deze problemen.

De basissyntaxis van een belofte wordt hieronder weergegeven;

var promise = doSomethingAync()
promise.then(onFulfilled, onRejected)

• “doSomethingAync” is een callback of asynchrone functie die een vorm van verwerking uitvoert.
• Deze keer is er bij het definiëren van de callback een waarde die wordt geretourneerd, een zogenaamde 'belofte'.
• Wanneer een promise wordt geretourneerd, kan deze 2 outputs hebben. Dit wordt gedefinieerd door de 'then clause'. De operatie kan een succes zijn, wat wordt aangegeven door de parameter 'onFulfilled'. Of het kan een fout hebben, wat wordt aangegeven door de parameter 'onRejected'.

Let op: Het belangrijkste aspect van een belofte is dus de retourwaarde. Er is geen concept van een retourwaarde bij het werken met normale callbacks in Node.js. Vanwege de retourwaarde hebben we meer controle over hoe de callback-functie kan worden gedefinieerd.

In het volgende onderwerp zullen we een voorbeeld zien van beloften en hoe deze profiteren van terugbelverzoeken.

Terugbellen naar beloftes

Laten we nu eens kijken naar een voorbeeld van hoe we “beloften” kunnen gebruiken vanuit een Node.js-applicatie. Om beloftes in een Node.js-applicatie te kunnen gebruiken, moet eerst de 'promise'-module worden gedownload en geïnstalleerd.

We zullen dan onze code aanpassen zoals hieronder weergegeven, die een werknemersnaam in de 'Employee'-verzameling bijwerkt met behulp van beloften.

Stap 1) De NPM-modules installeren

Om Promises vanuit een Node JS-applicatie te gebruiken, is de beloftemodule vereist. Voer de onderstaande opdracht uit om de beloftemodule te installeren

npm installatiebelofte

Stap 2) Wijzig de code om beloftes op te nemen

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 Uitleg:-

1. Het eerste deel is het opnemen van de 'promise'-module waarmee we de belofte-functionaliteit in onze code kunnen gebruiken.
2. We kunnen nu de 'dan'-functie toevoegen aan onze MongoClient.connect-functie. Wat dit dus doet, is dat wanneer de verbinding met de database tot stand is gebracht, we het daarna gedefinieerde codefragment moeten uitvoeren.
3. Ten slotte definiëren we ons codefragment dat het werk doet van het bijwerken van EmployeeName van de werknemer met de naam "Martin" naar "Mohan".

Opmerking: -

Als u nu de inhoud van uw MongoDB database, zult u zien dat als er een record met EmployeeName van “Martin” bestaat, deze wordt bijgewerkt naar “Mohan.”

Om te controleren of de gegevens correct in de database zijn ingevoegd, moet u de volgende opdrachten uitvoeren in MongoDB

1. Gebruik EmployeeDB
2. db.Employee.find({Naam werknemer:Mohan })

De eerste verklaring zorgt ervoor dat u verbonden bent met de EmployeeDb-database. De tweede verklaring zoekt naar het record met de werknemersnaam 'Mohan'.

Omgaan met geneste beloften

Bij het definiëren van beloften moet worden opgemerkt dat de ‘toen’-methode zelf een belofte teruggeeft. In zekere zin kunnen beloften dus aan elkaar worden gekoppeld.

In het onderstaande voorbeeld gebruiken we ketening om twee callback-functies te definiëren, die beide een record invoegen in de MongoDB database.

(Note: Chaining is een concept dat wordt gebruikt om de uitvoering van methoden aan elkaar te koppelen. Stel dat uw toepassing twee methoden had, genaamd 'methodeA' en 'methodeB'. En de logica was zodanig dat 'methodeB' na 'methodeA' moest worden aangeroepen, waarna je de uitvoering zo zou ketenen dat 'methodeB' direct na 'methodeA' wordt aangeroepen.)

Het belangrijkste om op te merken in dit voorbeeld is dat de code schoner, leesbaarder en beter te onderhouden is door het gebruik van geneste promises.

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 Uitleg:-

1. We definiëren nu twee “dan”-clausules die na elkaar worden uitgevoerd. In de eerste then-clausule geven we de parameter 'db' door die onze databaseverbinding bevat. Vervolgens gebruiken we de collection-eigenschap van de 'db'-verbinding om records in de 'Employee'-collectie in te voegen. De 'insertOne'-methode wordt gebruikt om het daadwerkelijke document in de werknemerscollectie in te voegen.
2. Wij gebruiken dan de 2^nd then-clausule om ook een ander record in de database in te voegen.

Als u nu de inhoud van uw MongoDB database, vindt u de twee records ingevoegd in de MongoDB database.

Een belofte op maat maken

Een aangepaste belofte kan worden gemaakt door een knooppuntmodule te gebruiken met de naam 'q.' De 'q'-bibliotheek moet worden gedownload en geïnstalleerd met behulp van de knooppuntpakketbeheerder. Na gebruik van de 'q' bibliotheek kan de methode “denodeify” worden aangeroepen, waardoor elke functie een functie wordt die een belofte retourneert.

In het onderstaande voorbeeld maken we een eenvoudige functie genaamd "Add" die 2 getallen optelt. We zetten deze functie om in een functie die een promise retourneert.

Zodra dat is gebeurd, zullen we de belofte gebruiken die wordt geretourneerd door de functie Toevoegen om een ​​bericht weer te geven in console.log.

Laten we de onderstaande stappen volgen om onze aangepaste functie te creëren om een ​​belofte terug te geven.

Stap 1) De NPM-modules installeren

Om 'q' vanuit een Node JS-applicatie te gebruiken, is de 'q'-module vereist. Om de 'q'-module te installeren, voert u de onderstaande opdracht uit

npm installeren q

Stap 2) Definieer de volgende code die gebruikt zal worden om de aangepaste belofte te maken.

Code Uitleg:-

1. Het eerste bit is het opnemen van de 'q'-bibliotheek door het trefwoord require te gebruiken. Door deze bibliotheek te gebruiken, kunnen we elke functie definiëren om terug te bellen.
2. We maken een functie genaamd Add die 2 getallen optelt die gedefinieerd zijn in variabelen a en b. De som van deze waarden wordt opgeslagen in variabele c.
3. Vervolgens gebruiken we de q-bibliotheek om onze Add-functie te denodeificeren (de methode die wordt gebruikt om elke functie om te zetten in een functie die een belofte retourneert) of om onze Add-functie op een andere manier om te zetten in een functie die een belofte retourneert.
4. We noemen nu onze functie "Toevoegen" en kunnen een retourbeloftewaarde krijgen vanwege de eerdere stap die we hebben uitgevoerd om de functie Toevoegen te denodeificeren.
5. Het sleutelwoord 'then' wordt gebruikt om aan te geven dat als de functie met succes wordt uitgevoerd, de tekenreeks 'Optellingsfunctie voltooid' wordt weergegeven in console.log.

Wanneer de bovenstaande code wordt uitgevoerd, wordt de uitvoer “Addition function completed” weergegeven in de console.log zoals hieronder weergegeven.

Samenvatting

• Het gebruik van callback-functies in Node.js heeft zijn nadelen. Soms kan het geneste gebruik van callback-functies tijdens het ontwikkelingsproces de code rommeliger en moeilijker te onderhouden maken.
• De meeste problemen met geneste callbackfuncties kunnen worden opgelost door het gebruik van promises en generators in node.js
• Een Promise is een waarde die door een asynchrone functie wordt geretourneerd om aan te geven dat de verwerking door de asynchrone functie is voltooid.
• Promises kunnen in elkaar worden genest om de code er beter uit te laten zien en gemakkelijker te onderhouden wanneer een asynchrone functie na een andere asynchrone functie moet worden aangeroepen