ES6篇（15）--Promise 对象

 

Promise对象
1.什么是Promise
Promise是异步编程的解决方案。Promise对象代表一个异步操作，有三种状态pending(进行中),fulfilled(成功),rejected(失败).

由异步操作的结果来决定当前是哪种状态，其他操作无法改变这个状态；并且状态一旦改变，就不会再变，任何时候都可以得到这个结果。
Promise对象的状态改变，只可能有两种：从pending变为fulfilled、从pending变为rejected
如果改变发生了，再对Promise对象添加回调函数，也会立即得到这个结果。

这与事件Event完全不同
事件的特点是，如果你错过了它，再去监听，是得不到结果的。

2.为什么要使用Promise
用Promise对象，可以将异步操作以同步操作的流程表达出来，避免层层嵌套的回调函数。
如果某些事件不断重复发生，一般来说使用Stream模式比部署Promise更好。
Promise的缺点：

（1）无法取消Promise，一旦新建它就会立即执行，无法中途取消
（2）如果不设置回调函数，Promise内部抛出的错误，不会反应到外部。
（3）当处于pending状态时，无法得知目前进展到哪一个阶段（刚刚开始还是即将完成）

3.Promise怎么用
基本语法：ES6规定，Promise对象是一个构造函数，是用来生成Promise实例的。
构造函数接受一个函数作为参数，该参数的两个参数分别是resolve和reject，它们是两个
函数，由JavaScript引擎提供，不用自己部署。
resolve函数和reject函数的作用是，修改Promise对象的状态并且将异步操作的结果，作为参数传递出去，

resolve函数是在异步操作成功时调用，reject函数是在异步操作失败时调用。

Promise实例生成以后，可以用then方法分别制定resolve状态和rejected状态的回调函数

原型方法Promise.protype.then()和Promise.protype.catch()
then方法可以接受两个回调函数作为参数，第一个回调函数是Promise对象状态变为resolved
时调用，第二个回调函数是Promise对象的状态变为rejected时调用。其中第二个函数是
可选的，不一定要提供。这两个函数都接受Promise对象传出的值作为参数。
小例子：
function timeout(ms) {
    return new Promise((resolve, reject) => {
        setTimeout(resolve, ms,"hhhh");
        
    });
}
调用：
timeout(5000).then((value) => {
        console.log("resolved结果",value);
    }, (value) => {
        console.log("rejected结果", value);
    });

特别注意
一般来说，调用resolve或reject以后，Promise 的使命就完成了，后继操作应该放到then方法里面，而不应该直接写在resolve或reject的后面。所以，最好在它们前面加上return语句，这样就不会有意外。

new Promise((resolve, reject) => {
  return resolve(1);
  // 后面的语句不会执行
  console.log(2);
})

※一个异步操作的结果是返回另一个异步操作

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

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

p2
  .then(result => console.log(result))
  .catch(error => console.log(error))

由于p2返回的是另一个Promise导致p2自己的状态无效了，由p1的状态决定p2的状态。

注意：下面两种写法，第二种优于第一种
// bad
promise
  .then(function(data) {
    // success
  }, function(err) {
    // error
  });

// good
promise
  .then(function(data) { //cb
    // success
  })
  .catch(function(err) {
    // error
  });
then方法返回一个promise，故then方法可以被同一个promise调用多次。

catch方法也是返回一个promise。catch方法执行后状态会变为resolved，也就是被catch方法捕获一次后，不会被下一个catch方法捕获（在这个catch方法中没有出现错误的前提下）。

Promise.protoype.finally()
这个方法不管Primise对象最后的状态如何，都会执行。finally方法的回调函数不接受任何
参数，在该方法里的操作与状态无关。finally方法总是会返回原来的值。

Promise.all()
该方法用于将多个Promise实例，包装成一个新的Promise实例。
例子：const 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的回调函数。

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

注意，如果作为参数的 Promise 实例，自己定义了catch方法，那么它一旦被rejected，并不会触发Promise.all()的catch方法。
因为在执行该Promise实例的catch方法后，也变成了resolved，故导致Promise.all()方法参数里面的两个实例都会resolved
于是会调用then方法指定的回调函数，而不调用catch方法指定的回调函数

Promise.race()
该方法也有用多个Promise实例，包装成一个新的Promise实例
例子：const p = Promise.race([p1, p2, p3]);
只要p1、p2、p3之中有一个实例率先改变状态，p的状态就跟着改变。那个率先改变的 Promise 实例的返回值，就传递给p的回调函数。

Promise.resolve()
将现有对象转为Promise对象
以下两种方法等价：Promise.resolve('foo')
// 等价于
new Promise(resolve => resolve('foo'))
Promise.resolve方法的参数分成四种

（1）参数是一个Promise实例--Promise.resolve不做任何修改，直接返回这个实例
（2）参数是一个thenable对象--thenable对象指的是具有then方法的对象，Promise.resolve
将会将这个对象转为Promise对象，然后立即执行thenable对象的then方法。

（3）参数不是具有then方法的对象，或根本就不是对象--Promise.resolve方法直接返回
Promise对象p，且Promise实例的状态从一生成就是resolved，且Promise.resolve方法的参数
会同时传给回调函数
（4）不带有任何参数--直接返回一个resolved状态的Promise对象。
需要注意的是：立即resolve()的 Promise 对象，是在本轮“事件循环”（event loop）的结束时执行，而不是在下一轮“事件循环”的开始时。
看看这个例子：
setTimeout(function () {
  console.log('three');
}, 0);

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

console.log('one');

// one
// two
// three

Promise.reject()
该方法也返回一个新的Promise实例，该实例的状态为rejected
注意：Promise.reject()方法的参数，会原封不动地作为reject的理由，变成后续方法的参数。这一点与Promise.resolve方法不一致。
如：const thenable = {
  then(resolve, reject) {
    reject('出错了');
  }
};

Promise.reject(thenable)
.catch(e => {
  console.log(e === thenable)
})
// true
这个例子中，Promise.reject方法的参数是一个thenable对象，执行后，后面的catch
方法的参数不是reject抛出的“出错了”这个字符串，而是thenable对象

Promise.try()

Promise.try(() => database.users.get({id: userId}))
  .then(...)
  .catch(...)

 

Promise.allSettled

Promise.allSettled()方法接受一组 Promise 实例作为参数，包装成一个新的 Promise 实例。只有等到所有这些参数实例都返回结果，不管是fulfilled还是rejected，包装实例才会结束.

下面是个例子：

const resolved = Promise.resolve(42);
const rejected = Promise.reject(-1);

const allSettledPromise = Promise.allSettled([resolved, rejected]);

allSettledPromise.then(function (results) {
  console.log(results);
});
// [
//    { status: 'fulfilled', value: 42 },
//    { status: 'rejected', reason: -1 }
// ]

 

上面代码中，Promise.allSettled()的返回值allSettledPromise，状态只可能变成fulfilled。它的监听函数接收到的参数是数组results。该数组的每个成员都是一个对象，对应传入Promise.allSettled()的两个 Promise 实例。每个对象都有status属性，该属性的值只可能是字符串fulfilled或字符串rejected。fulfilled时，对象有value属性，rejected时有reason属性，对应两种状态的返回值。

有时候，我们不关心异步操作的结果，只关心这些操作有没有结束。这时，Promise.allSettled()方法就很有用。

 

Promise.any

Promise.any()方法接受一组 Promise 实例作为参数，包装成一个新的 Promise 实例。只要参数实例有一个变成fulfilled状态，包装实例就会变成fulfilled状态；如果所有参数实例都变成rejected状态，包装实例就会变成rejected状态。

阮一峰ES6--Promise对象