Promise (Bluebird) 笔记整理

1. 基本用法

**例 1.1 创造一个Promise实例 **

var promise = new Promise(function(resolve, reject) {
  // ... some code
  if (/* 异步操作成功 */){
    resolve(value);
  } else {
    reject(error);
  }
});

例 1.2 用then方法分别指定Resolved状态和Reject状态的回调函数

promise.then(function(value) {
  // success
}, function(error) {
  // failure
});

then的第二个参数一般不写，最后统一用catch捕捉异常

例 1.3 Promise新建后就会立即执行

let promise = new Promise(function(resolve, reject) {
  console.log('Promise');
  resolve();
});
promise.then(function() {
  console.log('Resolved.');
});
console.log('Hi!');

// Promise
// Hi!
// Resolved

Promise新建后立即执行，所以首先输出的是“Promise”。然后，then方法指定的回调函数，将在当前脚本所有同步任务执行完才会执行，所以“Resolved”最后输出。

例 1.4 resolve()和reject()带有参数
若resolve(xxx)和reject(new Error()),则参数会被传递给回调函数。reject参数通常是new Error()表示抛出的错误; resolve函数的参数除了正常的值以外，还可能是另一个Promise实例 ，表示异步操作的结果有可能是一个值，也有可能是另一个异步操作.

var p1 = new Promise((resolve, reject) => {
    resolve('111')
    // reject(new Error('222'))
})
p1
.then(data => console.log(data))  // '111'
.catch(err => console.log(err)) // 捕获reject错误

var p1 = new Promise(function (resolve, reject) {
  setTimeout(() => reject(new Error('fail')), 3000)
})

var p2 = new Promise(function (resolve, reject) {
  setTimeout(() => resolve(p1), 1000)
})

p2
  .then(result => console.log(result))
  .catch(error => console.log(error))
// Error: fail

p1是一个Promise，3秒之后变为rejected。p2的状态在1秒之后改变，resolve方法返回的是p1。由于p2返回的是另一个 Promise，导致p2自己的状态无效了，由p1的状态决定p2的状态。所以，后面的then语句都变成针对后者（p1）。又过了2秒，p1变为rejected，导致触发catch方法指定的回调函数。

例 1.5 Promise.prototype.then()
then方法的第一个参数是Resolved状态的回调函数，第二个参数（可选）是Rejected状态的回调函数。
采用链式的then，可以指定一组按照次序调用的回调函数。这时，前一个回调函数，有可能返回的还是一个Promise对象（即有异步操作），这时后一个回调函数，就会等待该Promise对象的状态发生变化，才会被调用。

getJSON("/post/1.json").then(
  post => getJSON(post.commentURL)
).then(
  comments => console.log("Resolved: ", comments),
  err => console.log("Rejected: ", err)
);

例 1.6 Promise.prototype.catch()
Promise.prototype.catch方法是.then(null, rejection)的别名，用于指定发生错误时的回调函数。

p.then((val) => console.log('fulfilled:', val))
  .catch((err) => console.log('rejected', err));

// 等同于
p.then((val) => console.log('fulfilled:', val))
  .then(null, (err) => console.log("rejected:", err));

var promise = new Promise(function(resolve, reject) {
  // resolve('ok')
  // 写法 1 
  reject(new Error('test'));
  // 写法 2
  throw new Error('test');
  // 写法 3
  try {
    throw new Error('test');
  } catch(e) {
    reject(e);
  }
});

promise.catch(function(error) {
  console.log(error);
});

注意：若以上代码resolve('ok')生效，即Promise 在resolve语句后面，再抛出错误，不会被捕获，等于没有抛出。因为 Promise 的状态一旦改变，就永久保持该状态，不会再变了。

var promise = new Promise(function(resolve, reject) {
  resolve('ok');
  setTimeout(function() { throw new Error('test') }, 0)
});
promise.then(function(value) { console.log(value) });
// ok
// Uncaught Error: test

上面代码中，Promise 指定在下一轮“事件循环”再抛出错误，结果由于没有指定使用try...catch语句，就冒泡到最外层，成了未捕获的错误。因为此时，Promise的函数体已经运行结束了，所以这个错误是在Promise函数体外抛出的。

Node 有一个unhandledRejection事件，专门监听未捕获的reject错误.

process.on('unhandledRejection', function (err, p) {
  console.error(err.stack)
});

跟传统的try/catch代码块不同的是，如果没有使用catch方法指定错误处理的回调函数，Promise对象抛出的错误不会传递到外层代码，即不会有任何反应。

var someAsyncThing = function() {
  return new Promise(function(resolve, reject) {
    // 下面一行会报错，因为x没有声明
    resolve(x + 2);
  });
};

someAsyncThing().then(function() {
  console.log('everything is great');
});

上面代码中，someAsyncThing函数产生的Promise对象会报错，但是由于没有指定catch方法，这个错误不会被捕获，也不会传递到外层代码，导致运行后没有任何输出。注意，Chrome浏览器不遵守这条规定，它会抛出错误“ReferenceError: x is not defined”。

因为Promise内部的错误不会冒泡到全局，不管以then方法或catch方法结尾，要是最后一个方法抛出错误，都有可能无法捕捉到,此时你需要done()--例1.11

例 1.7 Promise.all
Promise.all方法用于将多个Promise实例 ，包装成一个新的Promise实例 。

var p = Promise.all([p1, p2, p3]);

Promise.all方法接受一个数组作为参数，p1、p2、p3都是Promise对象的实例 ，如果不是，就会先调用下面讲到的Promise.resolve方法，将参数转为Promise实例 ，再进一步处理。（Promise.all方法的参数可以不是数组，但必须具有Iterator接口，且返回的每个成员都是Promise实例 。）

p的状态由p1、p2、p3决定，分成两种情况:

1. 只有p1、p2、p3的状态都变成fulfilled，p的状态才会变成fulfilled，此时p1、p2、p3的返回值组成一个数组，传递给p的回调函数。

• 只要p1、p2、p3之中有一个被rejected，p的状态就变成rejected，此时第一个被reject的实例 的返回值，会传递给p的回调函数。

用 forEach() 处理promise
即在使用for循环、foreach()的时候如何使用promise

// 错误示范
// I want to remove() all docs
db.allDocs({include_docs: true}).then(function (result) {
    result.rows.forEach(function (row) {
        db.remove(row.doc);
    });
}).then(function () {
    // I naively believe all docs have been removed() now!
});

这段代码的问题在于第一个回调函数实际上返回的是 undefined，也就意味着第二个函数并不是在所有的db.remove() 执行结束之后才执行。事实上，第二个函数的执行不会有任何延时，它执行的时候被删除的doc数量可能为任意整数。

这时候你需要的是 Promise.all()

// 正确的写法
db.allDocs({include_docs: true}).then(function (result) {
    return Promise.all(result.rows.map(function (row) {
        return db.remove(row.doc);
    }));
}).then(function (arrayObject) {
    // All docs have really been removed() now!
})

例 1.8 Promise.race()

var p = Promise.race([p1, p2, p3]);

只要p1、p2、p3之中有一个实例 率先改变状态，p的状态就跟着改变。那个率先改变的 Promise 实例 的返回值，就传递给p的回调函数。

如果指定时间内没有获得结果，就将Promise的状态变为reject，否则变为resolve。

例 1.9 Promise.resolve()

**参数是一个Promise实例 **
如果参数是Promise实例 ，那么Promise.resolve将不做任何修改、原封不动地返回这个实例 。

参数是一个thenable对象
thenable对象指的是具有then方法的对象

let thenable = {
  then: function(resolve, reject) {
    resolve(42);
  }
};

Promise.resolve方法会将这个对象转为Promise对象，然后就立即执行thenable对象的then方法。

参数不是具有then方法的对象，或根本就不是对象
如果参数是一个原始值，或者是一个不具有then方法的对象，则Promise.resolve方法返回一个新的Promise对象，状态为Resolved。

var p = Promise.resolve('Hello');

p.then(function (s){
  console.log(s)
});
// Hello

不带有任何参数
Promise.resolve()直接返回一个Resolve状态的Promise对象

var p = Promise.resolve();
p.then(function () {
  // ...
});

注意，立即resolve的Promise对象，是在本轮“事件循环”（event loop）的结束时，而不是在下一轮“事件循环”的开始时。

setTimeout(function () {
  console.log('three');
}, 0);

Promise.resolve().then(function () {
  console.log('two');
});

console.log('one');

// one
// two
// three

记住，有可能抛出错误的代码都有可能因为错误被吞噬而对你的工作造成困扰。但是如果你用 Promise.resolve() 包装了代码的话，你永远都可以在代码后面加上 catch() 。

例 1.10 Promise.reject()
Promise.reject(reason)方法也会返回一个新的 Promise 实例 ，该实例 的状态为rejected。

注意，Promise.reject()方法的参数，会原封不动地作为reject的理由，变成后续方法的参数。这一点与Promise.resolve方法不一致。

const thenable = {
  then(resolve, reject) {
    reject('出错了');
  }
};

Promise.reject(thenable)
.catch(e => {
  console.log(e === thenable)
})
// true
// e参数是thenable对象

例 1.11 done()
Promise对象的回调链，不管以then方法或catch方法结尾，要是最后一个方法抛出错误，都有可能无法捕捉到（因为Promise内部的错误不会冒泡到全局）。因此，我们可以提供一个done方法，总是处于回调链的尾端，保证抛出任何可能出现的错误。

asyncFunc()
  .then(f1)
  .catch(r1)
  .then(f2)
  .done();

实现方法

Promise.prototype.done = function(onFulfilled, onRejected) {
  this.then(onFulfilled, onRejected)
    .catch(function (reason) {
      // 抛出一个全局错误
      setTimeout(() => { throw reason }, 0);
      });
}

done方法的使用，可以像then方法那样用，提供Fulfilled和Rejected状态的回调函数，也可以不提供任何参数。但不管怎样，done都会捕捉到任何可能出现的错误，并向全局抛出，然后用unhandledRejection捕获。

例 1.12 finally
finally方法用于指定不管Promise对象最后状态如何，都会执行的操作。它与done方法的最大区别，它接受一个普通的回调函数作为参数，该函数不管怎样都必须执行。

下面是一个例子，服务器使用Promise处理请求，然后使用finally方法关掉服务器。

server.listen(0)
  .then(function () {
    // run test
  })
  .finally(server.stop);

实现方法

Promise.prototype.finally = function (cb) {
  let P = this.constructor;   // 返回对此对象 Promise 的引用
  return this.then(
    value => P.resolve(cb()).then(() => value),
    reason => P.resolve(cb()).then(() => { throw reason })
    )
}

上面代码中，不管前面的Promise是fulfilled还是rejected，都会执行回调函数cb。

例 1.13 Promise.try()
实际开发中，经常遇到一种情况：不知道或者不想区分，函数f是同步函数还是异步操作，但是想用 Promise 来处理它。因为这样就可以不管f是否包含异步操作，都用then方法指定下一步流程，用catch方法处理f抛出的错误。

使用Promise.try()

const f = () => console.log('111');
Promise.try(f);
console.log('222');
// 111
// 222

由于Promise.try为所有操作提供了统一的处理机制，所以如果想用then方法管理流程，最好都用Promise.try包装一下。这样有许多好处，其中一点就是可以更好地管理异常。

function getUsername(userId) {
  return database.users.get({id: userId})
  .then(function(user) {
    return user.name;
  });
}

database.users.get()可能会抛出同步错误或者异步错误。

// 抛出异步错误
database.users.get({id: userId})
.then(...)
.catch(...)

// 同步错误（比如数据库连接错误，具体要看实现方法）
try {
  database.users.get({id: userId})
  .then(...)
  .catch(...)
} catch (e) {
  // ...
}

// 更优雅的操作，相信你会喜欢的
Promise.try(database.users.get({id: userId}))
  .then(...)
  .catch(...)

事实上，Promise.try就是模拟try代码块，就像promise.catch模拟的是catch代码块。

2. 更多