Fișă recapitulativă pentru biblioteca de promisiuni Bluebird.js

Bluebird Bluebird este o bibliotecă de promisiuni de înaltă performanță și bogată în funcționalități pentru JavaScript și Node.js.

Prezentare generală a înlănțuirii metodelor

promise
  .then(okFn, errFn)
  .spread(okFn, errFn)        // * Despachetează array-ul în argumente de funcție
  .catch(errFn)
  .catch(TypeError, errFn)    // * Interceptare filtrată a erorilor pe tipuri
  .finally(fn)
  .map(function (e) { /* ... */ })  // * Iterare concurentă
  .each(function (e) { /* ... */ }) // * Iterare secvențială

Metodele marcate cu * sunt extensii specifice Bluebird care depășesc specificația standard ES6.

Argumente multiple și despachetare (Promise.spread)

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

Vezi: Documentația Promise.spread: Promise.spread

Combinarea promisiunilor independente (Promise.join)

Coordonează multiple promisiuni independente cu o semnătură fixă:

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

Vezi: Documentația Promise.join: Promise.join

Metode pentru colecții de tablouri

Promise.all([p]): Se rezolvă când toate promisiunile reușesc, sau respinge la prima eroare.
Promise.some([p], count): Se rezolvă când un număr specificat de promisiuni reușește.
Promise.any([p]): Se rezolvă imediat ce o singură promisiune reușește.
Promise.map(array, fn, { concurrency: 5 }): Mapează elementele cu concurență controlată.

Promise.map(urls, url => fetch(url), { concurrency: 3 })
  .then(responses => {
    // Procesează răspunsurile cu maxim 3 cereri simultane
  });

Promisiuni în obiecte (Promise.props)

Rezolvă un obiect care conține promisiuni într-un obiect cu valorile rezolvate:

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

Promisificare (Conversie callback-uri)

Convertește funcțiile tradiționale cu callback din Node.js în promisiuni moderne:

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

// Promisificarea unei singure funcții
const readFile = Promise.promisify(fs.readFile);

// Promisificarea unui modul întreg
Promise.promisifyAll(fs);
// Acum fs.readFileAsync este disponibilă direct

Coroutine (Generatoare)

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