AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

图解 Promise 实现原理（二）—— Promise 链式调用

2020-04-23 1013
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 本系列文章由浅入深逐步实现 Promise，并结合流程图、实例以及动画进行演示，达到深刻理解 Promise 用法的目的。

本文首发于 vivo互联网技术 微信公众号 
链接： https://mp.weixin.qq.com/s/Xz2bGaLxVL4xw1M2hb2nJQ
作者：Morrain

很多同学在学习 Promise 时，知其然却不知其所以然，对其中的用法理解不了。本系列文章由浅入深逐步实现 Promise，并结合流程图、实例以及动画进行演示，达到深刻理解 Promise 用法的目的。

本系列文章有如下几个章节组成：

  1. 图解 Promise 实现原理（一）—— 基础实现

  2. 图解 Promise 实现原理（二）—— Promise 链式调用

  3. 图解 Promise 实现原理（三）—— Promise 原型方法实现

  4. 图解 Promise 实现原理（四）—— Promise 静态方法实现

一、前言

上一节中，实现了 Promise 的基础版本：

//极简的实现+链式调用+延迟机制+状态
class Promise {
    callbacks = [];
    state = 'pending';//增加状态
    value = null;//保存结果
    constructor(fn) {
        fn(this._resolve.bind(this));
    }
    then(onFulfilled) {
        if (this.state === 'pending') {//在resolve之前，跟之前逻辑一样，添加到callbacks中
            this.callbacks.push(onFulfilled);
        } else {//在resolve之后，直接执行回调，返回结果了
            onFulfilled(this.value);
        }
        return this;
    }
    _resolve(value) {
        this.state = 'fulfilled';//改变状态
        this.value = value;//保存结果
        this.callbacks.forEach(fn => fn(value));
    }
}

但链式调用，只是在 then 方法中 return 了 this，使得 Promise 实例可以多次调用 then 方法，但因为是同一个实例，调用再多次 then 也只能返回相同的一个结果，通常我们希望的链式调用是这样的：

//使用Promise
function getUserId(url) {
    return new Promise(function (resolve) {
        //异步请求
        http.get(url, function (id) {
            resolve(id)
        })
    })
}
getUserId('some_url').then(function (id) {
    //do something
    return getNameById(id);
}).then(function (name) {
    //do something
    return getCourseByName(name);
}).then(function (course) {
    //do something
    return getCourseDetailByCourse(course);
}).then(function (courseDetail) {
    //do something
});

每个 then 注册的 onFulfilled 都返回了不同的结果，层层递进，很明显在 then 方法中 return this 不能达到这个效果。引入真正的链式调用，then 返回的一定是一个新的Promise实例。

真正的链式 Promise 是指在当前 Promise 达到 fulfilled 状态后，即开始进行下一个 Promise（后邻 Promise）。那么我们如何衔接当前 Promise 和后邻 Promise 呢？（这是理解 Promise 的难点，我们会通过动画演示这个过程）。

二、链式调用的实现

先看下实现源码：

//完整的实现
class Promise {
    callbacks = [];
    state = 'pending';//增加状态
    value = null;//保存结果
    constructor(fn) {
        fn(this._resolve.bind(this));
    }
    then(onFulfilled) {
        return new Promise(resolve => {
            this._handle({
                onFulfilled: onFulfilled || null,
                resolve: resolve
            });
        });
    }
    _handle(callback) {
        if (this.state === 'pending') {
            this.callbacks.push(callback);
            return;
        }
        //如果then中没有传递任何东西
        if (!callback.onFulfilled) {
            callback.resolve(this.value);
            return;
        }
        var ret = callback.onFulfilled(this.value);
        callback.resolve(ret);
    }
    _resolve(value) {
        this.state = 'fulfilled';//改变状态
        this.value = value;//保存结果
        this.callbacks.forEach(callback => this._handle(callback));
    }
}

由上面的实现，我们可以看到：

  • then 方法中，创建并返回了新的 Promise 实例，这是串行Promise的基础，是实现真正链式调用的根本。

  • then 方法传入的形参 onFulfilled 以及创建新 Promise 实例时传入的 resolve 放在一起，被push到当前 Promise 的 callbacks 队列中，这是衔接当前 Promise 和后邻 Promise 的关键所在。

  • 根据规范，onFulfilled 是可以为空的，为空时不调用 onFulfilled。

看下动画演示：

（Promise 链式调用演示动画）

当第一个 Promise 成功时，resolve 方法将其状态置为 fulfilled ，并保存 resolve 带过来的value。然后取出 callbacks 中的对象，执行当前 Promise的 onFulfilled，返回值通过调用第二个 Promise 的 resolve 方法，传递给第二个 Promise。动画演示如下：

（Promise 链式调用 fulfilled）

为了真实的看到链式调用的过程，我写一个mockAjax函数，用来模拟异步请求：

/**
 * 模拟异步请求
 * @param {*} url  请求的URL
 * @param {*} s  指定该请求的耗时，即多久之后请求会返回。单位秒
 * @param {*} callback 请求返回后的回调函数
 */
const mockAjax = (url, s, callback) => {
    setTimeout(() => {
        callback(url + '异步请求耗时' + s + '秒');
    }, 1000 * s)
}

除此之外，我给 Promise 的源码加上了日志输出并增加了构造顺序标识，可以清楚的看到构造以及执行过程：

//Demo1
new Promise(resolve => {
  mockAjax('getUserId', 1, function (result) {
    resolve(result);
  })
}).then(result => {
  console.log(result);
})

【Demo1 的源码】

执行结果如下：

[Promse-1]:constructor
[Promse-1]:then
[Promse-2]:constructor
[Promse-1]:_handle state= pending
[Promse-1]:_handle callbacks= [ { onFulfilled: [Function], resolve: [Function] } ]
=> Promise { callbacks: [], name: 'Promse-2', state: 'pending', value: null }
[Promse-1]:_resolve
[Promse-1]:_resolve value= getUserId异步请求耗时1秒
[Promse-1]:_handle state= fulfilled
getUserId异步请求耗时1秒
[Promse-2]:_resolve
[Promse-2]:_resolve value= undefined

通过打印出来的日志，可以看到：

  1. 构造 Promise-1 实例，立即执行 mackAjax('getUserId',callback);

  2. 调用 Promise-1 的 then 方法，注册 Promise-1 的 onFulfilled 函数。

  3. then 函数内部构造了一个新的 Promise实例：Promise-2。立即执行 Promise-1 的 _handle方法。

  4. 此时 Promise-1 还是pending的状态。

  5. Promise-1._handle 中就把注册在 Promise-1 的 onFulfilled 和 Promise-2 的 resolve 保存在 Promise-1 内部的 callbacks。

  6. 至此当前线程执行结束。返回的是 Promise-2 的 Promise实例。

  7. 1s后，异步请求返回，要改变 Promise-1 的状态和结果，执行 resolve(result)。

  8. Promise-1 的值被改变，内容为异步请求返回的结果："getUserId异步请求耗时1s"。

  9. Promise-1 的状态变成 fulfilled。

  10. Promise-1 的 onFulfilled 被执行，打印出了"getUserId异步请求耗时1秒"。

  11. 然后再调用 Promise-2.resolve。

  12. 改变 Promise-2 的值和状态，因为 Promise-1 的 onFulfilled 没有返回值，所以 Promise-2的值为undefined。

上例中，如果把异步的请求改成同步会是什么的效果？

new Promise(resolve => {
  resolve('getUserId同步请求');
}).then(result => {
    console.log(result);
});

//打印日志
[Promse-1]:constructor
[Promse-1]:_resolve
[Promse-1]:_resolve value= getUserId同步请求
[Promse-1]:then
[Promse-2]:constructor
[Promse-1]:_handle state= fulfilled
getUserId同步请求
[Promse-2]:_resolve
[Promse-2]:_resolve value= undefined
=> Promise {
  callbacks: [],
  name: 'Promse-2',
  state: 'fulfilled',
  value: undefined }

感兴趣的可以自己去分析一下。

三、链式调用真正的意义

执行当前 Promise 的 onFulfilled 时，返回值通过调用第二个 Promise 的 resolve 方法，传递给第二个 Promise，作为第二个 Promise 的值。于是我们考虑如下Demo：

//Demo2
new Promise(resolve => {
    mockAjax('getUserId', 1, function (result) {
        resolve(result);
    })
}).then(result => {
    console.log(result);
    //对result进行第一层加工
    let exResult = '前缀:' + result;
    return exResult;
}).then(exResult => {
    console.log(exResult);
});

【Demo2 的源码】

我们加了一层 then，来看下执行的结果：

[Promse-1]:constructor
[Promse-1]:then
[Promse-2]:constructor
[Promse-1]:_handle state= pending
[Promse-1]:_handle callbacks= [ { onFulfilled: [Function], resolve: [Function] } ]
[Promse-2]:then
[Promse-3]:constructor
[Promse-2]:_handle state= pending
[Promse-2]:_handle callbacks= [ { onFulfilled: [Function], resolve: [Function] } ]
=> Promise { callbacks: [], name: 'Promse-3', state: 'pending', value: null }
[Promse-1]:_resolve
[Promse-1]:_resolve value= getUserId异步请求耗时1秒
[Promse-1]:_handle state= fulfilled
getUserId异步请求耗时1秒
[Promse-2]:_resolve
[Promse-2]:_resolve value= 前缀:getUserId异步请求耗时1秒
[Promse-2]:_handle state= fulfilled
前缀:getUserId异步请求耗时1秒
[Promse-3]:_resolve
[Promse-3]:_resolve value= undefined：

链式调用可以无限的写下去，上一级 onFulfilled return 的值，会变成下一级 onFulfilled 的结果。可以参考Demo3:

【Demo3 的源码】

我们很容易发现，上述 Demo3 中只有第一个是异步请求，后面都是同步的，我们完全没有必要这么链式的实现。如下一样能得到我们想要的三个结果: 分别打印出来的值。

//等价于 Demo3
new Promise(resolve => {
    mockAjax('getUserId', 1, function (result) {
        resolve(result);
    })
}).then(result => {
    console.log(result);
    //对result进行第一层加工
    let exResult = '前缀:' + result;
    console.log(exResult);

    let finalResult = exResult + ':后缀';
    console.log(finalResult);
});

那链式调用真正的意义在哪里呢？

刚才演示的都是 onFulfilled 返回值是 value 的情况，如果是一个 Promise 呢？是不是就可以通过 onFulfilled，由使用 Promise 的开发者决定后续 Promise 的状态。

于是在 _resolve 中增加对前一个 Promise onFulfilled 返回值的判断：

_resolve(value) {

        if (value && (typeof value === 'object' || typeof value === 'function')) {
            var then = value.then;
            if (typeof then === 'function') {
                then.call(value, this._resolve.bind(this));
                return;
            }
        }

        this.state = 'fulfilled';//改变状态
        this.value = value;//保存结果
        this.callbacks.forEach(callback => this._handle(callback));
    }

从代码上看，它是对 resolve 中的值作了一个特殊的判断，判断 resolve 的值是否为 Promise实例，如果是 Promise 实例，那么就把当前 Promise 实例的状态改变接口重新注册到 resolve 的值对应的 Promise 的 onFulfilled 中，也就是说当前 Promise 实例的状态要依赖 resolve 的值的 Promise 实例的状态。

//Demo4
const pUserId = new Promise(resolve => {
  mockAjax('getUserId', 1, function (result) {
    resolve(result);
  })
})
const pUserName = new Promise(resolve => {
  mockAjax('getUserName', 2, function (result) {
    resolve(result);
  })
})

pUserId.then(id => {
  console.log(id)
  return pUserName
}).then(name => {
  console.log(name)
})

【Demo 4 的源码】

执行的结果如下：

[Promse-1]:constructor
[Promse-2]:constructor
[Promse-1]:then
[Promse-3]:constructor
[Promse-1]:_handle state= pending
[Promse-1]:_handle callbacks= [ { onFulfilled: [Function], resolve: [Function] } ]
[Promse-3]:then
[Promse-4]:constructor
[Promse-3]:_handle state= pending
[Promse-3]:_handle callbacks= [ { onFulfilled: [Function], resolve: [Function] } ]
=> Promise { callbacks: [], name: 'Promse-4', state: 'pending', value: null }
[Promse-1]:_resolve
[Promse-1]:_resolve value= getUserId异步请求耗时1秒
[Promse-1]:_handle state= fulfilled
getUserId异步请求耗时1秒
[Promse-3]:_resolve
[Promse-3]:_resolve value= Promise { callbacks: [], name: 'Promse-2', state: 'pending', value: null }
[Promse-2]:then
[Promse-5]:constructor
[Promse-2]:_handle state= pending
[Promse-2]:_handle callbacks= [ { onFulfilled: [Function], resolve: [Function] } ]
[Promse-2]:_resolve
[Promse-2]:_resolve value= getUserName异步请求耗时2秒
[Promse-2]:_handle state= fulfilled
[Promse-3]:_resolve
[Promse-3]:_resolve value= getUserName异步请求耗时2秒
[Promse-3]:_handle state= fulfilled
getUserName异步请求耗时2秒
[Promse-4]:_resolve
[Promse-4]:_resolve value= undefined
[Promse-5]:_resolve
[Promse-5]:_resolve value= undefined

一样的，我做了一个演示动画，还原了这个过程：

（Promise 真正的链式调用）

至此，就实现了 Promise 链式调用的全部内容。链式调用是 Promise 难点，更是重点。一定要通过实例还有动画，深刻体会。下一节介绍 Promise 其它原型方法的实现。

文章标签：
前端开发
开发者
关键词：
Promise链式
Promise链式调用
Promise实现原理
2020Labs
目录
相关文章
凯小默
|
前端开发
18 # promise 的 finally 方法实现原理
18 # promise 的 finally 方法实现原理
凯小默
62 0
游客g7kiuqrvkhn3g
|
6月前
|
前端开发
Promise链式调用与错误处理
Promise链式调用是处理异步操作的方式，它按顺序执行多个任务，每个任务返回Promise对象。通过`.then()`指定成功后的操作，`.catch()`处理错误。示例代码展示了如何使用fetch获取数据，根据状态码解析响应并处理数据，错误则通过`.catch()`捕获。另一个例子定义了三个异步函数构成Promise链，依次执行并处理结果，错误同样由`.catch()`统一管理。
游客g7kiuqrvkhn3g
47 1
zcq5jk6y5y5e4
|
3月前
|
存储 JSON 前端开发
JavaScript异步编程3——Promise的链式使用
JavaScript异步编程3——Promise的链式使用
zcq5jk6y5y5e4
29 0
球球不吃虾
|
6月前
|
前端开发 JavaScript
Promise的链式调用案例讲解
Promise的链式调用案例讲解
球球不吃虾
23 0
陈俊刚
|
6月前
|
前端开发
Promise的链式调用
Promise的链式调用是指在一个Promise对象上连续调用多个then方法的过程。通过链式调用，可以将多个异步操作按照顺序执行，并且可以在每个操作完成后处理返回的结果。
陈俊刚
64 0
鋜斗
|
前端开发 程序员
promise的链式调用和promise的嵌套的实现
promise的链式调用和promise的嵌套的实现
鋜斗
187 0
游客ekifwqb233tlk
|
前端开发
手写Promise最简20行版本，实现异步链式调用。（重构版）
在面试的时候，经常会有面试官让你实现一个 Promise，如果参照 A+规范来实现的话，可能面到天黑都结束不了。
游客ekifwqb233tlk
96 0
颜酱
|
前端开发
重新手写promise，理解核心的异步链式调用原理
重新手写promise，理解核心的异步链式调用原理
颜酱
175 0
晚来南风晚相识
|
前端开发
Promise的异常穿透和中断Promise的链式请求
Promise的异常穿透和中断Promise的链式请求
晚来南风晚相识
664 0
血手巴赫
|
前端开发 JavaScript
面试题：promise的链式怎么实现的
promise的链式怎么实现的
血手巴赫
153 0

热门文章

最新文章

  • 1
    Promise实现原理（附源码）
  • 2
    BAT前端经典面试问题：史上最最最详细的手写Promise教程
  • 3
    Promise API 简介
  • 4
    【javascript】Promise/A+ 规范简单实现 异步流程控制思想
  • 5
    前端进阶|第四天从setTimeout、Promise看js 的异步机制
  • 6
    ES6(Promise)
  • 7
    推荐一本迷你中文书《JavaScript Promise迷你书（中文版）》
  • 8
    掌握 Promise.all：优雅处理多个异步操作
  • 9
    图解 Promise 实现原理（四）—— Promise 静态方法实现
  • 10
    JQuery的异步回调支持 - Promise、Deferred
  • 1
    JavaScript异步编程：Promise与async/await的深入探索
    41
  • 2
    js【详解】Promise（含 Promise 的三种状态及其变化，创建 Promise， Promise.all 语法、Promise.all 实战范例、手写 Promise.all）
    536
  • 3
    【微信小程序】使用 Promise、async 和 await 将异步API 改写为同步
    62
  • 4
    前后端数据交互-----ncaught (in promise) TypeError: this.registerAPI is not a function
    32
  • 5
    解决Edge输入document.querySelector(‘video‘).playbackRate = 2.5视频无法加速的问题，‘Uncaught (in promise) TypeErro’
    270
  • 6
    js 等待接口访问成功后执行指定代码【3种方法】（含async await Promise的使用）
    197
  • 7
    前端 JS 经典：Promise 详解
    74
  • 8
    JavaScript 等待异步请求数据返回值后，继续执行代码 —— async await Promise的使用方法
    54
  • 9
    Promise 等待多个接口返回数据再执行操作
    50
  • 10
    前端开发中的异步编程：Promise 和 Async/Await 的比较与应用
    93

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    DataWorks售前咨询