bluebird
Een callback-API omzetten in beloften.
Zoeken…
Opmerkingen
Beloften hebben de status, ze beginnen als in behandeling en kunnen genoegen nemen met:
- vervuld, wat betekent dat de berekening met succes is voltooid.
- afgewezen, wat betekent dat de berekening is mislukt.
Veelbelovende terugkerende functies mogen nooit gooien , maar moeten in plaats daarvan afwijzingen teruggeven. Het gooien van een belofte-terugkerende functie zal je dwingen om zowel een } catch { als een .catch . Mensen die beloofde API's gebruiken, verwachten niet dat beloftes worden gegooid. Als u niet zeker weet hoe async API's werken in JS, bekijk dan eerst dit antwoord .
Een hele NodeJS-module in één keer omzetten
Stel dat u een bibliotheek hebt die callbacks retourneert, bijvoorbeeld de fs module in NodeJS:
const fs = require("fs");
fs.readFile("/foo.txt", (err, data) => {
if(err) throw err;
console.log(data);
});
We willen het converteren naar een API voor belofte die terugkeert, met bluebird - we kunnen dit doen met promisifyAll dat een hele API converteert om beloftes te gebruiken:
const Promise = require("bluebird");
const fs = Promise.promisifyAll(require("fs"));
// this automatically adds `Async` postfixed methods to `fs`.
fs.readFileAsync("/foo.txt").then(console.log);
Hiermee kunt u de hele module gebruiken als beloften.
Hier zijn enkele veelvoorkomende ecxamples over het beloven van bepaalde modules:
// The most popular redis module
var Promise = require("bluebird");
Promise.promisifyAll(require("redis"));
// The most popular mongodb module
var Promise = require("bluebird");
Promise.promisifyAll(require("mongodb"));
// The most popular mysql module
var Promise = require("bluebird");
// Note that the library's classes are not properties of the main export
// so we require and promisifyAll them manually
Promise.promisifyAll(require("mysql/lib/Connection").prototype);
Promise.promisifyAll(require("mysql/lib/Pool").prototype);
// Mongoose
var Promise = require("bluebird");
Promise.promisifyAll(require("mongoose"));
// Request
var Promise = require("bluebird");
Promise.promisifyAll(require("request"));
// Use request.getAsync(...) not request(..), it will not return a promise
// mkdir
var Promise = require("bluebird");
Promise.promisifyAll(require("mkdirp"));
// Use mkdirp.mkdirpAsync not mkdirp(..), it will not return a promise
// winston
var Promise = require("bluebird");
Promise.promisifyAll(require("winston"));
// rimraf
var Promise = require("bluebird");
// The module isn't promisified but the function returned is
var rimrafAsync = Promise.promisify(require("rimraf"));
// xml2js
var Promise = require("bluebird");
Promise.promisifyAll(require("xml2js"));
// jsdom
var Promise = require("bluebird");
Promise.promisifyAll(require("jsdom"));
// fs-extra
var Promise = require("bluebird");
Promise.promisifyAll(require("fs-extra"));
// prompt
var Promise = require("bluebird");
Promise.promisifyAll(require("prompt"));
// Nodemailer
var Promise = require("bluebird");
Promise.promisifyAll(require("nodemailer"));
// ncp
var Promise = require("bluebird");
Promise.promisifyAll(require("ncp"));
// pg
var Promise = require("bluebird");
Promise.promisifyAll(require("pg"));
Een enkele NodeJS-functie omzetten
U kunt een enkele functie met een callback-argument omzetten in een Promise -returning-versie met Promise.promisify , dus dit:
const fs = require("fs");
fs.readFile("foo.txt", (err, data) => {
if(err) throw err;
console.log(data);
});
wordt:
const promisify = require("bluebird");
const readFile = promisify(require("fs").readFile));
readFile("foo.txt").then(console.log); // promisified version
Het omzetten van een andere callback-API
Om een callback-API om te zetten in beloften, uitgaande van de promisify en promisifyAll versies passen niet - u kunt de belofte-constructor gebruiken .
Beloftes maken betekent over het algemeen dat wordt aangegeven wanneer ze zich vestigen - dat wil zeggen wanneer ze naar de voltooide (voltooide) of afgewezen (foutieve) fase gaan om aan te geven dat de gegevens beschikbaar zijn (en toegankelijk zijn met .then ).
new Promise((fulfill, reject) => { // call fulfill/reject to mark the promise
someCallbackFunction((data) => {
fulfill(data); // we mark it as completed with the value
})
});
Laten we als voorbeeld setTimeout converteren om beloftes te gebruiken:
function delay(ms) { // our delay function that resolves after ms milliseconds
return new Promise((resolve, reject) => { // return a new promise
setTimeout(resolve, ms); // resolve it after `ms` milliseconds have passed
})
}
// or more concisely:
const delay = ms => new Promise(r => setTimeout(r, ms));
We kunnen het nu gebruiken als een normale terugkerende beloftefunctie:
delay(1000).then(() => console.log("One second passed")).
then(() => delay(1000)).
then(() => console.log("Another second passed"));