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 som är "återuppringningsfunktioner" i Node.js. Vi har sett dessa återuppringningsfunktioner mycket i de tidigare 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.
- 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.
- 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'.
Notera: 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.
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 ändra vår kod enligt nedan, som uppdaterar ett anställdsnamn i 'Anställd'-samlingen genom att använda löften.
Steg 1) Installation av NPM-moduler
För att använda Promises från en Node JS-applikation krävs löftesmodulen. För att installera löftemodulen, 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" } }); });
Kodförklaring:-
- Den första delen är att inkludera modulen "löfte" som gör att vi kan använda löftesfunktionen i vår kod.
- 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.
- Slutligen definierar vi vår kodsnutt som gör arbetet med att uppdatera EmployeeName för den anställde med namnet "Martin" till "Mohan".
Observera: -
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
- Använd EmployeeDB
- db.Employee.find({EmployeeName :Mohan })
Det första uttalandet säkerställer att du är ansluten till EmployeeDb-databasen. Det andra uttalandet söker efter posten som har anställds namn "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" }) }) });
Kodförklaring:-
- 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.
- Vi använder då 2nd 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 infogade i MongoDB databas.
Skapa ett anpassat löfte
Ett anpassat löfte kan skapas genom att använda en nodmodul som heter 'q.' 'q'-biblioteket måste laddas ner och installeras med hjälp av nodpakethanteraren. 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' från en Node JS-applikation krävs modulen 'q'. För att installera 'q'-modulen, 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.
Kodförklaring:-
- 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.
- 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.
- Vi använder sedan q-biblioteket för att denodeifiera (metoden som används för att konvertera vilken funktion som helst till en funktion som skulle returnera ett löfte) vår Add-funktion eller på annat sätt konvertera vår Add-funktion till en funktion som returnerar ett löfte.
- 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.
- Nyckelordet 'då' används och specificera att om funktionen körs framgångsrikt, visa strängen "Addition function completed" i console.log.
När ovanstående kod körs kommer utgången "Addition function completed" att visas i console.log som visas nedan.
Sammanfattning
- Att använda återuppringningsfunktioner i Node.js har sina nackdelar. Ibland under utvecklingsprocessen kan den kapslade användningen av återuppringningsfunktioner göra koden rörigare och svår att underhålla.
- De flesta av problemen med kapslade återuppringningsfunktioner kan mildras med hjälp av löften och generatorer i node.js
- Ett löfte är ett värde som returneras av en asynkron funktion för att indikera slutförandet av bearbetningen som utförs av den asynkrona funktionen.
- Löften kan kapslas in i varandra för att få koden att se bättre ut och enklare att underhålla när en asynkron funktion behöver anropas efter en annan asynkron funktion