Bluebird.js Promise-Bibliothek Spickzettel

Bluebird Bluebird ist eine hochperformante, funktionsreiche Promise-Bibliothek für JavaScript und Node.js.

Methodenverkettung im Überblick

promise
  .then(okFn, errFn)
  .spread(okFn, errFn)        // * Array in Argumente entpacken
  .catch(errFn)
  .catch(TypeError, errFn)    // * Gefilterter Fehler-Catch
  .finally(fn)
  .map(function (e) { /* ... */ })  // * Nebenläufig iterieren
  .each(function (e) { /* ... */ }) // * Sequentiell iterieren

Mit * markierte Methoden sind Bluebird-spezifische Erweiterungen über die ES6-Promise-Spezifikation hinaus.

Mehrere Argumente & Entpacken (Promise.spread)

Promise.resolve(['foo', 'bar'])
  .spread((item1, item2) => {
    console.log(item1, item2); // 'foo', 'bar'
  });

Siehe: Promise.spread Dokumentation: Promise.spread

Kombinieren fester Promises (Promise.join)

Koordiniert mehrere unabhängige Promises mit fester Signatur:

Promise.join(
  getPictures(),
  getMessages(),
  getTweets(),
  (pics, msgs, tweets) => {
    return { pics, msgs, tweets };
  }
);

Siehe: Promise.join Dokumentation: Promise.join

Array-Kollektionsmethoden

Promise.all([p]): Wird erfüllt, wenn alle Promises erfüllt sind, oder schlägt beim ersten Fehler fehl.
Promise.some([p], count): Wird erfüllt, wenn die angegebene Anzahl an Promises erfolgreich aufgelöst wurde.
Promise.any([p]): Wird erfüllt, sobald das erste Promise erfolgreich aufgelöst wurde.
Promise.map(array, fn, { concurrency: 5 }): Mappt Elemente mit kontrollierter Nebenläufigkeit.

Promise.map(urls, url => fetch(url), { concurrency: 3 })
  .then(responses => {
    // Antworten mit maximal 3 parallelen Anfragen verarbeiten
  });

Objekt-Promises (Promise.props)

Löst ein Objekt mit Promise-Werten in ein Objekt mit den aufgelösten Werten auf:

Promise.props({
  photos: getPhotos(),
  posts: getPosts()
}).then(result => {
  console.log(result.photos, result.posts);
});

Promisification (Callback zu Promise)

Klassische Node.js-Callback-Funktionen in moderne Promises umwandeln:

const fs = require('fs');
const Promise = require('bluebird');

// Eine einzelne Funktion promisifizieren
const readFile = Promise.promisify(fs.readFile);

// Ein gesamtes Modul promisifizieren
Promise.promisifyAll(fs);
// Jetzt steht fs.readFileAsync zur Verfügung

Coroutinen (Generatoren)

const loginUser = Promise.coroutine(function* (email, password) {
  const user = yield User.findOne({ email }).exec();
  const valid = yield user.comparePassword(password);
  if (!valid) throw new Error('Invalid credentials');
  return user;
});