node.js的Promise对象的使用

目录

• 一、Promise对象的定义
• 二、链式调用-then方法
• 三、捕获异常-catch
• 四、收尾执行-finally
• 五、其他方法
  • all
  • race
  • resolve
  • reject

一、Promise对象的定义

Promise对象用来将异步操作以同步操作的流程表达出来，定义如下

let flag = true;
const hello = new Promise(function (resolve, reject) {
    if (false) {//异步操作成功
        resolve("success");
    } else {
        reject("error");
    }
});

二、链式调用-then方法

使用then方法调用，第一个参数是成功回调，第二个参数是失败回调，如下

hello.then(
    function (value) {
        console.log(value)
    },
    function (err) {
        console.log(err)
    }
);

下面我们分别定义三个方法，参数为延时执行的秒数

1. chenqionghe
2. get
3. muslce

function chenqionghe(second) {
    return new Promise((resolve, reject) => {
        setTimeout(function () {
            console.log("chenqionghe");
            resolve();
        }, second * 1000);
    })
}
function get(second) {
    return new Promise((resolve, reject) => {
        setTimeout(function () {
            console.log("get");
            resolve()
        }, second * 1000);
    })
}

function muscle(second) {
    return new Promise((resolve, reject) => {
        setTimeout(function () {
            console.log("muscle");
            resolve();
        }, second * 1000);
    })
}

调用如下

chenqionghe(3)
    .then(function () {
        return get(2)
    })
    .then(function () {
        return muscle(1)
    });

运行输出

chenqionghe
get
muscle

这样就实现了链式的调用，相当于同步的方式执行了

如果不使用then调用，会发生什么情况？如下

chenqionghe(3);
get(2);
muscle(1);

结果如下

muscle
get
chenqionghe

我们看到chenqionghe虽然是第一个执行，却是最后输出内容，因为设置了3秒后执行

重点：

1. Promise 对象的错误具有“冒泡”性质，会一直向后传递，直到被捕获为止。也就是说，错误总是会被下一个catch语句捕获。
2. 一般来说，不要在then方法里面定义 Reject 状态的回调函数（即then的第二个参数），总是使用catch方法。

三、捕获异常-catch

chenqionghe(3)
    .then(function () {
        return get(2)
    })
    .then(function () {
        throw new Error("abc");
        return muscle(1)
    })
    .catch(function (e) {
        console.log("异常:" + e.message)
    })
;

输出

chenqionghe
get
异常:abc

异常本质也是一个Promise，所以后面还可以执行then

chenqionghe(3)
    .then(function () {
        return get(2)
    })
    .then(function () {
        throw new Error("abc");
        return muscle(1)
    })
    .catch(function (e) {
        console.log("异常:" + e.message)
    })
    .then(function () {
        console.log("异常后执行")
    })
;

运行输出

chenqionghe
get
异常:abc
异常后执行

四、收尾执行-finally

就是不管怎么样，都会执行的方法，即使是抛异常了

chenqionghe(3)
    .then(function () {
        return get(2)
    })
    .then(function () {
        throw new Error("abc");
        return muscle(1)
    })
    .catch(function (e) {
        console.log("异常:" + e.message)
    })
    .finally(function () {
        console.log("最后都会执行的方法")
    })
;

执行输出

chenqionghe
get
异常:abc
最后都会执行的方法

finally本质上也是then方法的特例

五、其他方法

all

用于将多个promise实例包装成一个新的promise实例

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

1. 当p1、p2、p3都执行功能，会调用p的回调函数，传p1、p2、p3返回值的一个数组
2. 当p1、p2、p3其中有一个执行reject，第一个执行reject方法的返回值会传递给p的回调函数

race

类似all，也将多个promise实例包装成一个新的promise实例
不同的是，要p1、p2、p3之中有一个实例发生改变，最先改变的 Promise 实例的返回值会传递给p的回调函数。

resolve

将现有对象转为 Promise 对象

Promise.resolve('foo')
// 等价于
new Promise(resolve => resolve('foo'))

reject

返回一个新的 Promise 实例，该实例的状态为rejected

const p = Promise.reject('出错了');
// 等同于
const p = new Promise((resolve, reject) => reject('出错了'))