Node.js Promise Handledning

I tidigare handledningar skulle du ha sett återuppringningsfunktioner som används för asynkrona händelser. Men ibland kan återuppringningsfunktioner bli en mardröm när de börjar bli kapslade, och programmet börjar bli långt och komplext.

Vad är löften?

Innan vi börjar med löften, låt oss först se över vad "callback"-funktioner är i node.jsVi har sett dessa återanropsfunktioner mycket i de föregående kapitlen, så låt oss snabbt gå igenom en av dem.

Exemplet nedan visar ett kodavsnitt, som används för att ansluta till en MongoDB databas och utför en uppdateringsoperation på en av posterna i databasen.

1. I ovanstående kod är delen av funktionen(err,db) känd som deklarationen av en anonym funktion eller återuppringningsfunktion. När MongoClient skapar en anslutning till MongoDB databasen, kommer den att återgå till återuppringningsfunktionen när anslutningsoperationen är klar. Så på sätt och vis sker anslutningsoperationerna i bakgrunden, och när det är klart anropar det vår återuppringningsfunktion. Kom ihåg att detta är en av nyckelpunkterna i Node.js för att tillåta många operationer att ske samtidigt och därmed inte blockera någon användare från att utföra en operation.
2. Det andra kodblocket är det som exekveras när callback-funktionen faktiskt anropas. Callback-funktionen uppdaterar bara en post i vår MongoDB databas.

Så vad är då ett löfte? Nåväl, ett löfte är bara en förbättring av återuppringningsfunktioner i Node.js. Under utvecklingens livscykel kan det finnas ett fall där du skulle behöva kapsla flera återuppringningsfunktioner tillsammans. Detta kan bli lite rörigt och svårt att underhålla vid en viss tidpunkt. Kort sagt, ett löfte är en förbättring av återuppringningar som syftar till att lindra dessa problem.

Den grundläggande syntaxen för ett löfte visas nedan;

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

• "doSomethingAync" är en återuppringning eller asynkron funktion som gör någon form av bearbetning.
• Den här gången, när återuppringningen definieras, finns det ett värde som returneras som kallas ett "löfte".
• När ett löfte returneras kan det ha 2 utgångar. Detta definieras av "då-satsen". Antingen kan operationen bli en framgång vilket betecknas med parametern 'onFulfilled'. Eller det kan ha ett fel som betecknas med parametern 'onRejected'.

A löfte sitter i en av tre stater och bosätter sig en gång:

Obs: Så nyckelaspekten av ett löfte är returvärdet. Det finns inget koncept för ett returvärde när man arbetar med normala återuppringningar i Node.js. På grund av returvärdet har vi mer kontroll över hur callback-funktionen kan definieras.

Versionsnotering: Dessa exempel körs fortfarande på Node.js 24, den aktiva LTS-linjen år 2026. Sedan Node.js 15 an ohanterad avvisning avslutar processen istället för att skriva ut en varning, så stäng varje kedja med .catch().

I nästa ämne kommer vi att se ett exempel på löften och hur de drar nytta av callbacks.

Återuppringningar till löften

Låt oss nu titta på ett exempel på hur vi kan använda "löften" från en Node.js-applikation. För att kunna använda löften i en Node.js-applikation måste modulen 'löfte' först laddas ner och installeras.

Vi kommer sedan att modifiera vår kod enligt nedan, vilket uppdaterar ett EmployeeName i samlingen 'Employee' med hjälp av löften.

Steg 1) Installera NPM-moduler

För att använda Promises inifrån en Node.js-applikation krävs promise-modulen. För att installera promise-modulen, kör kommandot nedan.

npm installera lovar

Steg 2) Ändra koden så att den inkluderar löften

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 Förklaring:

1. Den första delen är att inkludera modulen "löfte" som gör att vi kan använda löftesfunktionen i vår kod.
2. Vi kan nu lägga till "då"-funktionen till vår MongoClient.connect-funktion. Så vad detta gör är att när anslutningen är upprättad till databasen måste vi köra kodavsnittet som definieras därefter.
3. Slutligen definierar vi vår kodsnutt som gör arbetet med att uppdatera EmployeeName för den anställde med namnet "Martin" till "Mohan".

Obs:

Om du nu kontrollerar innehållet i din MongoDB databas, kommer du att upptäcka att om en post med EmployeeName av "Martin" finns, kommer den att uppdateras till "Mohan."

För att kontrollera att data har infogats korrekt i databasen måste du utföra följande kommandon i MongoDB

1. använd EmployeeDB
2. db.Employee.find({Medarbetarnamn: “Mohan”})

Den första satsen säkerställer att du är ansluten till EmployeeDB-databasen. Den andra satsen söker efter posten som har medarbetarnamnet "Mohan".

Hantera kapslade löften

När man definierar löften måste det noteras att "då"-metoden i sig returnerar ett löfte. Så på sätt och vis kan löften vara kapslade eller kedjade till varandra.

I exemplet nedan använder vi chaining för att definiera 2 callback-funktioner, som båda infogar en post i MongoDB databas.

(Anmärkningar: Kedjning är ett begrepp som används för att koppla exekvering av metoder till varandra. Anta att din ansökan hade två metoder som heter 'metodA' och 'metodB'. Och logiken var sådan att 'metodB' skulle anropas efter 'metodA', då skulle du kedja exekveringen på ett sådant sätt att 'metodB' anropas direkt efter 'metodA'.)

Det viktigaste att notera i det här exemplet är att koden blir renare, läsbar och underhållbar genom att använda kapslade löften.

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 Förklaring:

1. Vi definierar nu 2 "då"-satser som exekveras en efter en. I den första satsen skickar vi parametern 'db' som innehåller vår databasanslutning. Vi använder sedan samlingsegenskapen för 'db'-anslutningen för att infoga poster i 'Employee'-samlingen. Metoden 'insertOne' används för att infoga det faktiska dokumentet i Employee-samlingen.
2. Vi använder då 2^nd sedan klausul också för att infoga en annan post i databasen.

Om du nu kontrollerar innehållet i din MongoDB databasen hittar du de 2 posterna som infogades i MongoDB databas.

Modern motsvarighet: async och await, standard sedan ES2017, konsumerar dessa löften utan sedan återanrop och har till stor del ersatt generatorbaserad flödeskontrollbibliotek som co, medan inbyggt stöd för Promise gör q och bluebird redundanta. Det andra blocket visar att de sedan endast tar emot databas.

Skapa ett anpassat löfte

Ett anpassat löfte kan skapas med hjälp av en Node.js-modul som heter 'q'. 'q'-biblioteket måste laddas ner och installeras med hjälp av Node Package Manager. Efter att ha använt 'q'-biblioteket kan metoden "denodeify" anropas, vilket gör att vilken funktion som helst blir en funktion som returnerar ett löfte.

I exemplet nedan kommer vi att skapa en enkel funktion som heter "Lägg till" som lägger till 2 nummer. Vi kommer att konvertera denna funktion till en funktion för att returnera ett löfte.

När det är gjort kommer vi att använda löftet som returneras av funktionen Lägg till för att visa ett meddelande i console.log.

Låt oss följa stegen nedan för att skapa vår anpassade funktion för att returnera ett löfte.

Steg 1) Installation av NPM-moduler

För att använda 'q' inifrån en Node.js-applikation krävs modulen 'q'. För att installera modulen 'q', kör kommandot nedan.

npm installera q

Steg 2) Definiera följande kod som kommer att användas för att skapa det anpassade löftet.

Code Förklaring:

1. Den första biten är att inkludera 'q'-biblioteket genom att använda nyckelordet require. Genom att använda det här biblioteket kommer vi att kunna definiera vilken funktion som helst för att returnera en återuppringning.
2. Vi skapar en funktion som heter Add som lägger till 2 tal definierade i variablerna a och b. Summan av dessa värden kommer att lagras i variabel c.
3. Vi använder sedan q-biblioteket för att avkoda (metoden som används för att konvertera en funktion till en funktion som skulle returnera ett löfte) vår Add-funktion eller med andra ord, konvertera vår Add-funktion till en funktion som returnerar ett löfte.
4. Vi kallar nu vår "Lägg till"-funktion och kan få ett returlöftesvärde på grund av det föregående steget vi utförde för att denodeifiera Add-funktionen.
5. Nyckelordet 'then' används för att ange att om funktionen körs korrekt ska strängen "Addition function completed" visas i console.log.

När ovanstående kod körs kommer utgången "Addition function completed" att visas i console.log som visas nedan.

Vanliga frågor