Promise

有工夫能够具体看看阮一峰的教程。
参考教程

一 Promise 是什么？解决了什么问题？

​ Promise 是一个保留着异步操作后果的对象。

​ Promise 代替了传统的异步编程（回调函数，事件）计划，并且更加弱小。

二 Promise 特点

​（1） 对象的状态不受外界影响

​ (2) 状态一旦被更改就不会再变

三 Promise 毛病

​ (1) 无奈中途勾销，一旦创立就会立刻执行

​ (2) 如果不设置回调函数，Promise 外部的谬误不会反馈到内部

​ (3) 当处于 Pending 状态时，无奈得悉以后曾经进行到哪一步

四 Promise 构造函数是同步还是异步? then 办法呢？

​ (1) promise 构造函数是同步执行的，Promise 新建后会立刻执行（同步）。

​ (2) then 办法是异步执行的。

Promise 罕用办法如下：

五 then()

​ then 办法是 Promise 实例状态扭转时回调函数。

​ then 办法的参数是 resolve reject

​ then 办法返回的是一个新的 Promise 实例 。

六 catch()

​ catch 办法是一个用来解决产生谬误时的回调函数。

七 finally()

​ finally 办法不论 Promise 对象最初状态如何，都会执行的操作。

​ 应用场景：完结申请时的加载动画 ……

七 all()

​ all 办法承受由一个或多个 Promise 实例组成的数组。

​ all 办法中：如下例子: 参数中的 Promise 实例只有有一个被 rejected, 那么最终后果就是 rejected, 始终返回的是第一个被 rejected 的实例

let b1  = new Promise((resolve,reject) => {setTimeout(() => {resolve('b1 胜利') }, 1000);
})

let b2  = new Promise((resolve,reject) => {setTimeout(() => {reject('b2 失败') }, 500);
})

let b3  = new Promise((resolve,reject) => {setTimeout(() => {reject('b3 失败')   }, 200);
})

Promise.all([b1,b2,b3]).then(res => {console.log(res);  //  Uncaught (in promise) b3 失败
})

​ all 办法中：如下例子: 参数中的 Promise 实例全副 fulfilled, 最终后果才是 fulfilled

let b1  = new Promise((resolve,reject) => {setTimeout(() => {resolve('b1 胜利') }, 1000);
})

let b2  = new Promise((resolve,reject) => {setTimeout(() => {resolve('b2 胜利') }, 500);
})

let b3  = new Promise((resolve,reject) => {setTimeout(() => {resolve('b3 胜利')   }, 200);
})

Promise.all([b1,b2,b3]).then(res => {console.log(res);  // ['b1 胜利', 'b2 胜利', 'b3 胜利']
}) 

八 race()

​ race 办法承受由一个或多个 Promise 实例组成的数组。

​ race 办法最终状态：第一个完结的实例状态是个啥，最终后果就是个啥。请具体比拟如下例子

​ 上面的例子就像你同时跟三个妹纸聊天，就看哪个更快回复你。

let b1  = new Promise((resolve,reject) => {setTimeout(() => {resolve('b1 胜利') }, 1000);
})

let b2  = new Promise((resolve,reject) => {setTimeout(() => {reject('b2 失败') }, 100);
})

let b3  = new Promise((resolve,reject) => {setTimeout(() => {resolve('b3 胜利')   }, 10);
})


Promise.race([b1,b2]).then(res => {console.log(res);  // (in promise) b2 失败
    // 实例 b2 失率先失败后：间接返回后果，就不论了 b1 是个啥了。}) 

Promise.race([b2,b3]).then(res => {console.log(res);  // b3 胜利
    // 实例 b3 率先胜利后间接返回后果，不论 b2 了
}) 

九 allSettled()

​ allSettled 办法承受由一个或多个 Promise 实例组成的数组。

​ allSettled 办法不论这一组实例最终的后果怎么样，反正等这组实例全副执行完结后才执行。

let b1  = new Promise((resolve,reject) => {setTimeout(() => {resolve('b1 胜利') }, 1000);
})

let b2  = new Promise((resolve,reject) => {setTimeout(() => {reject('b2 失败') }, 100);
})

let b3  = new Promise((resolve,reject) => {setTimeout(() => {resolve('b3 胜利')   }, 10);
})


Promise.allSettled([b1,b2,b3]).then(res => {console.log(res);  

    /* 
       [{status: 'fulfilled', value: 'b1 胜利'}
          {status: 'rejected', reason: 'b2 失败'}
          {status: 'fulfilled', value: 'b3 胜利'}
        ] 
    */
}) 

十 any()

​ any 办法承受由一个或多个 Promise 实例组成的数组。

​ any 办法始终返回这组实例中率先胜利的那个，如果这组实例全副失败：最终后果就是失败 。

        
let a1  = new Promise((resolve,reject) => {setTimeout(() => {reject('a1 失败') }, 10);
})

let a2  = new Promise((resolve,reject) => {setTimeout(() => {reject('a2 失败') }, 50);
})

let a3  = new Promise((resolve,reject) => {setTimeout(() => {resolve('a3 胜利')   }, 100);
})
Promise.any([a1,a2,a3]).then(res => {console.log(res);   // a3 胜利
}) 

//---------------------------------------------------------
let a1  = new Promise((resolve,reject) => {setTimeout(() => {reject('a1 失败') }, 10);
})

let a2  = new Promise((resolve,reject) => {setTimeout(() => {reject('a2 失败') }, 50);
})

let a3  = new Promise((resolve,reject) => {setTimeout(() => {reject('a3 失败')   }, 100);
})
Promise.any([a1,a2,a3]).then(res => {console.log(res);   //  All promises were rejected
})