Promise

1.Promise 是什么？

（1）从语法上看：

对象；
构造函数： const promise = new Promise()

（2）从行为上看：

**异步编程**的解决方案

（3）基本语法：

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

// 处理Promise对象的状态改变
promise.then(value => {
 console.log(value); // "success"
}).catch(error => {
 console.log(error); // "error"
});

2.Promise对象两大特点

（1）状态不受外界影响

三种状态：pengding、resolved(fulfilled)、rejected

Promise对象代表一个异步操作
只有异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状态。

（2）一旦状态改变，就不会再变

状态变化：pending ======》 resolved
         pending ======》 rejected

3.Promise缺点

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

4.Promise 新建后就会立即执行

let promise = new Promise(function(resolve, reject) {
 // 此处代码同步执行
 console.log('promise----0');
 resolve();
});

promise.then(function() {
 console.log('promise----1');
});

console.log('promise----2');
// 打印结果
/*
 promise----0
 promise----2
 promise----1
*/

then方法指定的回调函数，是异步任务，将在当前脚本所有同步任务执行完才会执行，所以resolved最后输出。

5.原型上的方法

（1）Promise.prototype.then

constructor -> fn --同步--> resolve(reject) -> then -> then 回调
constructor -> fn --异步--> then -> resolve(reject) -> then 回调</pre>

*   作用：为 Promise 实例添加状态改变时的回调函数。`then`方法的第一个参数是`resolved`状态的回调函数，第二个参数是`rejected`状态的回调函数，它们都是可选的。

*   then方法返回的是一个新的Promise实例。所以可以采用链式写法，即then方法后面再调用另一个then方法。前一个回调函数，有可能返回的还是一个`Promise`对象（即有异步操作），这时后一个回调函数，就会等待该`Promise`对象的状态发生变化，才会被调用。

getAsyncData()
 .then((data) => {
 // 处理数据
 return processedData;
 })
 .then((processedData) => {
 // 进一步处理数据
 return finalData;
 })
 .catch((error) => {
 // 处理错误
 console.error(error);
 });

（2）Promise.prototype.catch

catch()方法返回的还是一个 Promise 对象，因此后面还可以接着调用then()方法。

getAsyncData()
 .then((data) => {
 // 处理数据
 return processedData;
 })
 .then((processedData) => {
 // 进一步处理数据
 return finalData;
 })
 .catch((error) => {
 // 处理错误
 console.error(error);
 });

用于指定发生错误时的回调函数,上面代码中，getJSON()方法返回一个 Promise 对象，如果该对象状态变为resolved，则会调用then()方法指定的回调函数；如果异步操作抛出错误，状态就会变为rejected，就会调用catch()方法指定的回调函数，处理这个错误。另外，then()方法指定的回调函数，如果运行中抛出错误，也会被catch()方法捕获。

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

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

例子：

const promise = new Promise((resolve, reject) => {
 throw new Error('catch-demo')
})
promise.catch(error => {
console.log('error', error)
})
// 输出：error, catch-demo

（3）Promise.prototype.finally

finally()方法用于指定不管 Promise 对象最后状态如何，都会执行的操作。

promise
.then(result => {···})
.catch(error => {···})
.finally(() => {···});

finally方法的回调函数不接受任何参数，这意味着没有办法知道，前面的 Promise 状态到底是fulfilled还是rejected。这表明，finally方法里面的操作，应该是与状态无关的，不依赖于 Promise 的执行结果。

promise
.finally(() => {
 // 语句
});

// 等同于
promise
.then(
 result => {
 // 语句
 return result;
 },
 error => {
 // 语句
 throw error;
 }
);

上面代码中，如果不使用finally方法，同样的语句需要为成功和失败两种情况各写一次。有了finally方法，则只需要写一次。

6.其它方法

（1）Promise.all()

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

接受一个数组作为参数，每个参数都是Promise实例，如果不是，会先调用Promise.resolve()方法，将参数转换为Promise实例。

const p = Promise.all([p1, p2, p3]);
// p1、p2、p3都是Promise实例

Promise.all()方法的参数可以不是数组，但必须具有 Iterator 接口，且返回的每个成员都是 Promise 实例。

上述代码p的状态由p1、p2、p3决定，分两种情况。

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

如果作为参数的Promise实例，自己定义了catch方法，一旦被rejected()，就不会触发Promise.all()的catch方法。

const p1 = new Promise((resolve, reject) => {
     resolve('Hello World!');
    })
    .then(result => result)
    .catch(e => e);
    
    const p2 = new Promise((resolve, reject) => {
     throw new Error('发生错误');
    })
    .then(result => result)
    .catch(e => e);
    
    Promise.all([p1, p2])
    .then(result => console.log(result))
    .catch(e => console.log(e));
    // ["hello", Error: 报错了]
    /*
    p1 ====> resolved
    p2 ====> rejected  ===> catch() ==== resolved
    所以Promise.all()方法参数两个实例都会resolved,因此会调用then方法指定的回调函数，而不会调用catch方法指定的回调函数。
    
    */

如果参数没有自己的catch方法，就会调用Promise.all()的catch`方法。

（2）Promise.race()

Promise.race()方法同样是将多个 Promise 实例，包装成一个新的 Promise 实例。

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

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

Promise.race()方法的参数与Promise.all()方法一样，如果不是 Promise 实例，就会先调用下面讲到的Promise.resolve()方法，将参数转为 Promise 实例，再进一步处理。

（3）Promise.allSettled()

希望等到一组异步操作都结束了，不管每一个操作是成功还是失败，再进行下一步操作。此时，Promise.all()与Promise.race()都无法满足这个要求。

ES2020 引入了Promise.allSettled()方法，用来确定一组异步操作是否都结束了（不管成功或失败）。所以，它的名字叫做”Settled“，包含了”fulfilled“和”rejected“两种情况。

Promise.allSettled()方法接受一个数组作为参数，数组的每个成员都是一个 Promise 对象，并返回一个新的 Promise 对象。只有等到参数数组的所有 Promise 对象都发生状态变更（不管是fulfilled还是rejected），返回的 Promise 对象才会发生状态变更。该方法返回的新的 Promise 实例，一旦发生状态变更，状态总是fulfilled，不会变成rejected。

（4）Promise.any()

该方法接受一组 Promise 实例作为参数，包装成一个新的 Promise 实例返回。

只要参数实例有一个变成fulfilled状态，包装实例就会变成fulfilled状态；如果所有参数实例都变成rejected状态，包装实例就会变成rejected状态。

Promise.any()跟Promise.race()方法很像，只有一点不同，就是Promise.any()不会因为某个 Promise 变成rejected状态而结束，必须等到所有参数 Promise 变成rejected状态才会结束。