Bluebird NPM: Bluebird JS Promise med exempel

Vad är Bluebird JS?

Bluebird JS är ett fullfjädrat Promise-bibliotek för JavaSkript. Dess starkaste funktion är att den låter dig "promisify" andra Node-moduler för att kunna använda dem asynkront. Promisify är ett koncept som tillämpas på callback-funktioner, och det säkerställer att varje callback-funktion som anropas returnerar ett värde.

Så om en node.js Modulen innehåller en callback-funktion som inte returnerar ett värde, vilket lovar att modulen automatiskt modifierar alla funktioner i den så att var och en returnerar ett värde.

Det här betyder att du kan använda Bluebird för att göra MongoDB modulen körs asynkront, vilket gör det ännu enklare att skriva Node.js-applikationer.

Exemplet nedan upprättar först en anslutning till samlingen ”Employee” i databasen ”EmployeeDB”. När anslutningen är upprättad hämtas alla poster i samlingen och visas i konsolen.

Hur man skapar löften med Bluebird JS Library

Här är ett steg-för-steg-exempel som visar hur man genererar löften med Bluebird JS-biblioteket.

Steg 1) Installera NPM-modulerna

För att använda Bluebird inifrån en Node-applikation krävs Bluebird-modulen. Installera den med kommandot nedan:

npm install bluebird

Steg 2) Inkludera Bluebird-modulen

Nästa steg är att inkludera Bluebird-modulen i din kod och lova hela MongoDB modulen. Att lova här innebär att Bluebird säkerställer att varje metod som definieras i MongoDB biblioteket ger ett löfte.

Code Förklaring:

1. Ocuco-landskapet require kommandot inkluderar Bluebird-biblioteket.
2. Bluebird's .promisifyAll() Metoden skapar en asynkron version av varje metod MongoDB modulen tillhandahåller, så var och en körs i bakgrunden och returnerar ett löfte.

Steg 3) Anslut till databasen

Det sista steget är att ansluta till databasen, hämta alla poster i samlingen och visa dem i konsolloggen.

Code Förklaring:

1. Lägg märke till connectAsync metoden används istället för den vanliga connect metod. Bluebird lägger till Asynk suffix till varje metod i MongoDB bibliotek för att skilja de anrop som returnerar löften från de som inte gör det. Metoder utan suffixet Async har ingen sådan garanti.
2. Liknar connectAsync, den findAsync metoden returnerar alla poster i MongoDB "Anställd"-kollektionen.
3. If findAsync löses korrekt itererar följande block igenom varje post i samlingen och visar den i konsolloggen.

Om stegen ovan utförs korrekt visas alla dokument i Employee-samlingen i konsolen, som visas i utdata nedan.

Här är den kompletta koden för referens:

var Promise = require('bluebird');

// promisifyAll adds an Async variant of every MongoDB method
var mongoClient = Promise.promisifyAll(require('mongodb')).MongoClient;

mongoClient.connectAsync('mongodb://localhost/EmployeeDB')

    .then(function(db) {
        return db.collection('Employee').findAsync({});
    })
    .then(function(cursor) {
        cursor.each(function(err, doc) {
            console.log(doc);
        });
    });

⚠️ Anmärkning om drivrutinsversion: koden ovan mål MongoDB Noddrivrutin 2.x, där connect löser med ett databasobjekt. Från drivrutinen 3.0 och framåt det löser sig med en MongoClient, så kedjan måste ringa client.db('EmployeeDB').collection('Employee') istället för db.collection('Employee')Moderna drivrutinsversioner returnerar också redan inbyggda löften, vilket gör promisifyAll onödig för MongoDB specifikt.

Bluebird vs Native Promises: Vilken ska man använda

När Bluebird först skrevs hade Node inget stöd för promises alls, så biblioteket fyllde ett verkligt tomrum i plattformen. Node har levererat native promises sedan version 4 och async/await sedan version 7.6, vilket förändrar beräkningen avsevärt för alla som startar ett projekt idag.

Välj nativa löften för nytt arbete, eftersom de inte behöver något beroende och integreras direkt med async await. Använd Bluebird när ett beroende fortfarande endast exponerar återanrop, eller när dess samtidighetshjälpare, som till exempel Promise.map med en samtidighetsgräns, spara en betydande mängd kod.

Hur man hanterar fel med Bluebird Promises

Exemplet ovan har ingen felväg. Om MongoDB inte körs, eller om samlingsnamnet är fel, avvisas kedjan och ingenting skrivs ut — processen avslutas helt enkelt utan förklaring. Varje löfteskedja behöver en terminalhanterare.

Bluebird-stöd .catch() för avslag och .finally() för rensning som måste köras åt båda hållen. Den stöder även typade fångster, som hanterar en felklass medan andra sprider sig.

var Promise = require('bluebird');
var mongoClient = Promise.promisifyAll(require('mongodb')).MongoClient;

var connection;

mongoClient.connectAsync('mongodb://localhost/EmployeeDB')
    .then(function(db) {
        connection = db;
        return db.collection('Employee').findAsync({});
    })
    .then(function(cursor) {
        return cursor.toArrayAsync();
    })
    .then(function(docs) {
        docs.forEach(function(doc) { console.log(doc); });
    })
    .catch(Promise.TimeoutError, function(err) {
        console.error('The database did not respond in time.');
    })
    .catch(function(err) {
        // Any other rejection from any step above arrives here
        console.error('Query failed:', err.message);
    })
    .finally(function() {
        // Runs on success and on failure, so the socket always closes
        if (connection) { connection.close(); }
    });

Tre vanor spelar roll här. För det första, plats .catch() i slutet snarare än efter varje steg, eftersom en terminalhanterare tar emot avslag från varje föregående länk i kedjan. För det andra, använd .finally() för att frigöra resurser som en databasanslutning, eftersom den körs på både lyckade och misslyckade vägar. För det tredje, lämna aldrig en kedja utan en fångst: en ohanterad avvisning avslutar Node-processen i aktuella versioner, och Bluebird kommer att skriva ut en uttrycklig varning om det i förväg. Aktivera lång stack traces under utveckling med Promise.config({ longStackTraces: true }) gör det mycket lättare att lokalisera ursprunget till ett avslag.

Vanliga Bluebird Promisify-fel och lösningar

De flesta Bluebird-problem uppstår på grund av namngivningskonventionen Promisified, eller från att man blandar callback- och promise-anropsstilarna i samma kedja, snarare än från något fel i själva biblioteket. Varje symptom nedan anger dess orsak och lösning.

• "connectAsync är inte en funktion": modulen behövdes direkt istället för via promisifyAll(), så inga async-varianter finns. Radbryt require-anropet som visas ovan.
• Anropar plain-metoden och får odefinierad: connect() förväntar sig fortfarande en återanropning. Endast kopian med async-suffixet returnerar ett löfte.
• Skicka en återanrop till en async-metod: leverera varken en återuppringning eller await och löftet löses obemärkt. Använd en stil per anrop, inte båda.
• promisifyAll på ett redan promise-baserat bibliotek: ofarligt men meningslöst, och det producerar förvirrande namn med dubbla suffix. Kontrollera bibliotekets dokumentation först.
• Förlora fel i tysthet: en kedja utan .catch() döljer orsaken till avslaget tills Node rapporterar ett ohanterat avslag och avslutar. Avsluta alltid kedjan med en catch, även i korta skript.

Vanliga frågor