promise对象（“承诺”）

零、异步编程：

• Javascript语言的执行环境是"单线程"
  好处是实现起来简单，执行环境相对单纯；
  但只要有一个拖着，后面的都必须排队等着，拖延整个程序的执行。出现“假死”现象。
• Javascript语言将任务的执行模式分成两种：
  同步（Synchronous）和异步（Asynchronous）。
• 异步模式：每一个任务有一个或多个回调函数（callback），前一个任务结束后，不是执行后一个任务，而是执行回调函数，后一个任务则是不等前一个任务结束就执行。
  方法：
  • 回调函数
  • 事件监听
  • 发布/订阅
  • Promises对象

此文主要谈谈promise

一、promise对象

1.三种状态：

• pending（进行中）
• fulfilled（已成功）
• rejected（已失败）
  一旦状态改变就不会再变！即称为resolved（已定型）（既然是承诺嘛怎么会轻易改变对吧>~<）
• pending->fulfilled
• pending->rejected

2.用法

（1）构造promise实例（函数作为参数，函数的参数有resolve和reject(要么成功要么失败难道还有第三个选项吗略略略)）

const promise = new Promise(function(resolve, reject) {
  // ... some code

  if (/* 异步操作成功 */){
    resolve(value);
  } else {
    reject(error);
  }
});

（2）用then方法分别指定resolved状态和rejected状态的回调函数。（失败不是必要的，成功才是必须滴）

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

3.promise.prototype.then()

（1）Promise 实例具有then方法，也就是说，then方法是定义在原型对象Promise.prototype上的。（关于原型的东西可以去看看高程函数的章节，很清晰）
（2）then方法返回的是一个新的Promise实例（注意，不是原来那个Promise实例）。因此可以采用链式写法，即then方法后面再调用另一个then方法。第一个回调函数完成以后，会将返回结果作为参数，传入第二个回调函数。

getJSON("/posts.json").then(function(json) {
  return json.post;
}).then(function(post) {
  // ...
});

（3）前一个回调函数，有可能返回的还是一个Promise对象（即有异步操作），这时后一个回调函数，就会等待该Promise对象的状态发生变化，才会被调用。

4.promise.prototype.catch()

（1）是.then(null, rejection)的别名，用于指定发生错误时的回调函数。

getJSON('/posts.json').then(function(posts) {
  // ...
}).catch(function(error) {
  // 处理 getJSON 和 前一个回调函数运行时发生的错误
  console.log('发生错误！', error);
});

（2）then方法指定的回调函数，如果运行中抛出错误，也会被catch方法捕获。
（3）Promise 对象的错误具有“冒泡”性质，会一直向后传递，直到被捕获为止。错误总是会被下一个catch语句捕获。

getJSON('/post/1.json').then(function(post) {
  return getJSON(post.commentURL);
}).then(function(comments) {
  // some code
}).catch(function(error) {
  // 处理前面三个Promise产生的错误
});

（4）如果没有使用catch方法指定错误处理的回调函数，Promise 对象抛出的错误不会传递到外层代码
（所以要用 catch啊！）catch方法返回的还是一个 Promise 对象，因此后面还可以接着调用then方法。

5.Promise.all与Promise.race

将多个 Promise 实例，包装成一个新的 Promise 实例。

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

all就像一个团队合作，，只要有一个人失败了那么整个项目就是失败，必须所有人都成功了才是最终的胜利！

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

race只要有一个率先改变状态，整体的状态就跟着改变。那个率先改变的返回值，就传递给p的回调函数。

6.Promise.resolve

将现有对象转为Promise对象
（1）参数是一个Promise实例,将不做任何修改、原封不动地返回这个实例。（我就是承诺本身，不需要任何改变）

（2）参数是一个thenable对象，指的是具有then方法的对象

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

则先将这个对象转为Promise对象，然后就立即执行thenable对象的then方法。
（3）参数不是具有then方法的对象，或根本就不是对象，则返回一个新的Promise对象，状态为resolved。（ 初来乍到给你点成功尝尝甜头先哈哈哈）
（4）不带有任何参数
Promise.resolve方法允许调用时不带参数，直接返回一个resolved状态的Promise对象。

7.Promise.reject(reason)

返回一个新的 Promise 实例，该实例的状态为rejected。

8.done

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

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

9.finally

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

server.listen(0)
  .then(function () {
    // run test
  })
  .finally(server.stop);
//服务器使用Promise处理请求，然后使用finally方法关掉服务器

10.promise.try()

const f = () => console.log('now');
Promise.try(f);
console.log('next');
// now
// next

让同步函数同步执行，异步函数异步执行，并且让它们具有统一的 API

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

• 其他的做法
  （1）async函数

const f = () => console.log('now');
(async () => f())();
console.log('next');
// now
// next
//注意：async () => f()会吃掉f()抛出的错误。
//如果想捕获错误，使用promise.catch。

（2）new Promise()

const f = () => console.log('now');
(
  () => new Promise(
    resolve => resolve(f())
  )
)();
console.log('next');
// now
// next

二、任何的东西都会有缺点：

无法取消，一旦建立就会立刻执行；
如果无回调函数，其内部抛出的错误不会反应到外部；
处于pending状态无法得知是进展到哪个阶段（刚开始？or快完成？this is a question.）