Promise详解

一、什么是promise?

Promise 是的一种异步加载解决方案，其实是一个构造函数，自己身上有all、reject、resolve这几个方法，原型上有then、catch等方法。补充：什么是原型？

Promise特点：

(1) 对象的状态不受外界影响。Promise对象代表一个异步操作，有三种状态：pending（进行中）、fulfilled（已成功）和rejected（已失败）。只有异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状态。这也是Promise这个名字的由来，它的英语意思就是“承诺”，表示其他手段无法改变。

(2) 一旦状态改变，就不会再变，任何时候都可以得到这个结果。Promise对象的状态改变，只有两种可能：从Pending变为Resolved和从Pending变为Rejected。只要这两种情况发生，状态就凝固了，不会再变了，会一直保持这个结果。就算改变已经发生了，你再对Promise对象添加回调函数，也会立即得到这个结果。

(3) 构造函数 Promise 必须接收一个函数（handle）作为参数，函数又包含 resolve 和 reject ；

(4) then 、catch 支持链式调用

Promise能解决什么问题？

1、promise本质上是给出了一种异步任务同步写法的解决方案，然后才是解决回调地狱问题；

2、其中还会涉及微任务宏任务问题；先执行宏任务，再执行微任务

3、anysc await 其实本质是promise.then的执行结果；但是其更完美的体现了异步任务同步执行的形式(补充：anysc与await)

二、Promise基本用法

1.基本用法

ES6规定，Promise对象是一个构造函数，用来生成Promise实例，它接受一个函数作为参数，该函数的两个函数参数分别是resolve和reject，resolve的作用是将Promise对象的状态从未完成变为成功，reject函数的作用是将Promise对象的状态从未完成变为失败。

    let p = new Promise(function (resolve, reject) {
        setTimeout(() => {
            console.log('执行成功');
            resolve('我是成功！！！！');
            reject('我是失败！！！！')
        }, 2000)
    });

2.then 

Promise实例生成以后，可以用then方法分别指定resolved状态和rejected状态的回调函数（一般rejected状态交由catch专门处理）

    p.then((data) => {
        console.log(data);
        return data
    }).then((data) => {
        console.log(data);
    }).then((data) => {
        console.log(data);//undefined 因为上一步then没有返回值
    })

 3.catch

和then一样,catch方法返回的也是一个Promise对象，因此后面还可以接着调用then()方法，如果没有报错，则会跳过catch()方法。此时，要是后面的then()方法里面报错，就与前面的catch()无关了

    p.then((data) => {
        console.log('resolved', data);
        console.log(a);
    }).catch((err) => {
        console.log('rejected', err);//因为a未被定义，所以err返回的是rejected ReferenceError: a is not defined
    });

4.finally

finally()方法是用于指定不管 Promise 对象最后状态如何，都会执行的操作。该方法总是会返回原来的值，并且不接受任何参数，这意味着没有办法知道前面的 Promise状态到底是fulfilled还是rejected。

p.then((data)=>{
    console.log(111);
})
.catch((error)=>{
    console.log(222);
})
.finally((data)=>{
    console.log(333);
});

5.all 

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

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

（1）只有p1、p2、p3的状态都变成fulfilled，p的状态才会变成fulfilled，此时p1、p2、p3的返回值组成一个数组，传递给p的回调函数。
（2）只要p1、p2、p3之中有一个被rejected，p的状态就变成rejected，此时第一个被reject的实例的返回值，会传递给p的回调函数。(简单来说就是有一个结果为rejected，结果就是rejected)

例子实现：

（补充：返回的result是一个数组）

    let p1 = new Promise((resolve, reject) => {
        resolve('成功了')
    })

    let p2 = new Promise((resolve, reject) => {
        resolve('success')
    })

    let p3 = Promise.reject('失败')

    Promise.all([p1, p2]).then((result) => {
        console.log(result)               //['成功了', 'success']
    }).catch((error) => {
        console.log(error)
    })

    Promise.all([p1, p3, p2]).then((result) => {
        console.log(result)
    }).catch((error) => {
        console.log(error)      // 失败了，打出 '失败'
    })

6.race 

与上面的all()一样，都是用于将多个Promise实例，包装成一个新的Promise实例。race的意思是竞赛，和字面意思一样，谁第一个完成，就取谁作为结果。下面代码中，只要p1,p2,p3之中有一个实例率先改变状态，p的状态就跟着改变。率先改变的Promise实例的返回值，就传递给p的回调函数

    let p1 = new Promise((resolve, reject) => {
        setTimeout(()=>{
             resolve('成功了')
        },4000)
       
    })

    let p2 = new Promise((resolve, reject) => {
        setTimeout(()=>{
             resolve('success')
        },2000)
    })

    let p3 = Promise.reject('失败')

    Promise.race([p1, p3, p2]).then((result) => {
        console.log(result)
    }).catch((error) => {
        console.log(error)      // 失败了，打出 '失败'
    })

7.any 

any()方法同样是将多个 Promise 实例，包装成一个新的 Promise实例。any()有一个子实例成功就算成功，全部子实例失败才算失败。