Promise简介

Promise是什么？

Promise是异步编程的一种解决方案，它是一个对象，可以获取异步操作的消息，他的出现大大改善了异步编程的困境，避免了地狱回调，它比传统的解决方案回调函数和事件更合理和更强大。

Promise对象创建的实例有三种状态

• pending（进行中）
• fulfilled（已完成）
• rejected（已拒绝）

如何创建Promise实例

new Promise()

Promise构造函数接收一个函数作为参数，该函数的两个参数分别是resolve和reject。

• resolve : 将Promise对象的状态从 Pending(进行中) 变为 Fulfilled(已成功)
• reject : 将Promise对象的状态从 Pending(进行中) 变为 Rejected(已失败)，并抛出错误。

 const p = new Promise(function (resolve, reject) {
        setTimeout(() => {
            let data = "数据库的数据111";
            let error = "获取失败";
            // resolve(data)
            reject(error);
        }, 1000);
});
    const res = p.then(
        function (data) {
            console.log(data, "获取成功");
        },
        function (error) {
            console.log(error, "获取失败");
            return 'lsh'
        }
    );

Promise.resolve

  // Promise.resolve创建promise实例
    Promise.resolve(11).then(function(val){
        console.log(val, 'val');
    })

如果插入的参数是非Promise类型的对象，则返回的结果为成功的promise对象
如果插入的参数是Promise对象，则参数的结果决定resolve创建的实例的结果

Promise.reject

  // Promise.reject创建promise实例
    Promise.reject('失败').catch(error=>{
        console.log(error, 'error');
    })

使用reject方法创建的实例的状态永远都是rejected，不管参数是数字、字符串或一个成功的promise对象。

Promise方法

(1).then()

then方法可以接受两个回调函数作为参数。第一个回调函数是Promise对象的状态变为resolved时调用，第二个回调函数是Promise对象的状态变为rejected时调用。其中第二个参数可以省略。

then方法基本使用

 // Promise.then方法
    Promise.resolve(11).then(function (val) {
        console.log(val, 'val');
    }, function (error) {
        console.log(error, 'error');
    })

then方法返回的是一个新的Promise实例（不是原来那个Promise实例）。因此可以采用链式写法，即then方法后面再调用另一个then方法。

then方法链式写法

(2).catch()（then方法的第二个参数）

该方法相当于then方法的第二个参数，指向reject的回调函数。不过catch方法还有一个作用，就是在执行resolve回调函数时，如果出现错误，抛出异常，不会停止运行，而是进入catch方法中。

// Promise.catch方法
    Promise.reject('失败').catch(error => {
        console.log(error, 'error');
    })

(3)all()（全部是fulfilled才返回fulfilled）

all方法可以完成并行任务，它接受一个数组，数组得每一项都是一个promise对象。当数组中所有的promise的状态都达到fulfilled时，all方法的状态也会是fulfilled，如果有一个状态变成了rejected，那么all方法的状态就会变成rejected。

调用all方法结果成功时的回调函数的参数也是一个数组，这个数组按顺序保存着每一个promise对象resolve执行时的值。而失败的时候则返回最先被reject失败状态的值。

let promise1 = new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve(1);
        }, 2000)
    });
    let promise2 = new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve(2);
        }, 1000)
    });
    let promise3 = new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve(3);
        }, 3000)
    });
    // Promise.all方法
    const res = Promise.all([promise1, promise2, promise3]).then(res => {
        console.log(res);
        //结果为：[1,2,3] 
})
    setTimeout(() => {
        console.log(res, 'res');
    }, 4000)

(4)race()（返回第一个promise对象的值）

race方法和all一样，接受的参数是一个每项都是promise的数组，但是与all不同的是，当最先执行完的事件执行完之后，就直接返回该promise对象的值。如果第一个promise对象状态变成fulfilled，那自身的状态变成了fulfilled；反之第一个promise变成rejected，那自身状态就会变成rejected。

 let promise1 = new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve(1);
        }, 500)
    });
    let promise2 = new Promise((resolve, reject) => {
        setTimeout(() => {
            reject(2);
        }, 200)
    });
    const res = Promise.race([promise1, promise2])
    setTimeout(() => {
        console.log(res, 'res');
    }, 1000)

(5)finally()（不接受任何参数）

finally方法用于指定不管promise最后的状态，在执行完then或catch指定的回调函数以后，都会执行finally方法指定的回调函数。该方法是 ES2018 引入标准的。
下面是一个例子，服务器使用 Promise 处理请求，然后使用finally方法关掉服务器。

    server.listen(port)
        .then(function () {
            // ...
        })
        .finally(server.stop);