Antisèche de la bibliothèque de promesses Bluebird.js

Bluebird Bluebird est une bibliothèque de promesses hautes performances et riche en fonctionnalités pour JavaScript et Node.js.

Aperçu du chaînage de méthodes

promise
  .then(okFn, errFn)
  .spread(okFn, errFn)        // * Décompresse un tableau en arguments
  .catch(errFn)
  .catch(TypeError, errFn)    // * Capture d'erreur filtrée par type
  .finally(fn)
  .map(function (e) { /* ... */ })  // * Itération concurrente
  .each(function (e) { /* ... */ }) // * Itération séquentielle

Les méthodes marquées d'un * sont des extensions exclusives à Bluebird qui complètent le standard ES6.

Arguments multiples et décompression

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

Voir : Documentation de Promise.spread: Promise.spread

Combinaison de promesses indépendantes (Promise.join)

Coordonne plusieurs promesses indépendantes avec une signature déterminée :

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

Voir : Documentation de Promise.join: Promise.join

Méthodes pour collections de tableaux

Promise.all([p]): Résolu quand toutes les promesses réussissent, ou rejeté dès la première erreur.
Promise.some([p], count): Résolu quand un nombre spécifique de promesses réussissent.
Promise.any([p]): Résolu dès que n'importe quelle promesse individuelle réussit.
Promise.map(array, fn, { concurrency: 5 }): Itère sur les éléments avec concurrence maîtrisée.

Promise.map(urls, url => fetch(url), { concurrency: 3 })
  .then(responses => {
    // Traitement avec un maximum de 3 requêtes simultanées
  });

Promesses d'objets (Promise.props)

Résout un objet contenant des promesses en un objet contenant les valeurs résolues :

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

Promisification (Callbacks vers Promesses)

Convertit les fonctions avec rappels Node.js en promesses modernes :

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

// Promisifier une seule fonction
const readFile = Promise.promisify(fs.readFile);

// Promisifier un module complet
Promise.promisifyAll(fs);
// La méthode fs.readFileAsync est maintenant disponible

Coroutines (Générateurs)

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;
});