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
})