js手写Promise（上）

news/2024/7/10 22:56:56 标签: javascript, 前端, 开发语言, es6

目录

  • 构造函数
    • resolve与reject
    • 状态改变
      • 状态改变后就无法再次改变
    • 代码优化
    • 回调函数中抛出错误
  • then
    • onFulfilled和onRejected的调用时机
    • 异步then
    • 多个then

如果是不知道或者对Promise不熟悉的铁铁可以先看我这篇文章
Promise

构造函数

在最开始，我们先不去考虑Promise内部是怎么实现，而是先将自己的Promise声明出来，这里我使用ES6的class来声明

javascript">class MyPromise {

}

在我们new一个Promise的时候会传入一个回调函数，这个回调函数有两个形参，一个resolve，一个reject，这个函数将交给Promise来立即执行，所以我们的constructor可以这么写

javascript">class MyPromise {
	constructor(func) {
		func(resolve, reject)
	}
}

值得注意的是，Promise本身就是一个任务，而回调函数表示的是任务的执行过程，所以constructor中的形参应该叫executor而不是func

javascript">class MyPromise {
	constructor(executor) {
		executor(resolve, reject)
	}
}

resolve与reject

resolve和reject也是函数，那么这两个函数定义在哪呢，有2种方案

  1. 定义在constructor中

    javascript">constructor(executor) {
    const resolve = (data) => {

    }
    const reject = (reason) => {

    }
    executor(resolve, reject)
}

  2. 将其变为原型方法

    javascript">class MyPromise {
constructor(executor) {
    func(this.#resolve, this.#reject)
}
#reject(reason) { }
#resolve(data) { }
}

    因为这个函数我们只会在类的内部使用，并不希望用户能在外部访问，所以我们将它定义为私有成员
    只不过这么写的话会有this的指向问题，我们需要使用强制绑定来将函数绑定到正确的地方

    javascript">class MyPromise {
constructor(executor) {
    func(this.#resolve.call(this), this.#reject.call(this))
}
#reject(reason) { }
#resolve(data) { }
}

这里我选择第一种方法

状态改变

现在我们声明了resolve与reject两个函数，但具体这两个函数做什么我们并不清楚，事实上这两个函数做的都是同一件事，改变当前Promise实例的状态与值，只不过resolve是将当前实例的状态改为fulfilled，而reject是将当前实例的状态改为rejected，明白了这一点我们就能写出如下代码

javascript">class MyPromise {
    #state = "pending"
    #value = null
    constructor(executor) {
        const resolve = (data) => {
            this.#state = "fulfilled"
            this.#value = data
        }
        const reject = (reason) => {
            this.#state = "rejected"
            this.#value = reason
        }
        executor(resolve, reject)
    }
}

我们声明了两个私有属性，无论是state还是value我们都不希望用户能从外部访问，state用于记录当前实例的状态，而value用于记录当前实例得到的值

状态改变后就无法再次改变

这么写就完了吗？当然没有，在Promise中状态一旦确定就不能再更改，反映到代码层面就是无论是在回调函数中写多少个resolve和reject，Promise都只会执行第一个，而我们的Promise中目前并没有实现这个功能

javascript">const resolve = (data) => {
    if (this.#state !== "pending") return
    this.#state = "fulfilled"
    this.#value = data
}
const reject = (reason) => {
    if (this.#state !== "pending") return
    this.#state = "rejected"
    this.#value = reason
}

我们在resolve和reject上都加了一行判断，如果当前实例的state不是pending的话就说明状态已经改变，不能再继续执行
写到这里我们发现resolve和reject函数中的重复代码有点多，所以我们可以将其封装成一个独立的函数

javascript">class MyPromise {
    #state = "pending"
    #value = null
    constructor(executor) {
        const resolve = (data) => {
            this.#changeState("fulfilled", data)
        }
        const reject = (reason) => {
            this.#changeState("rejected", reason)
        }
        executor(resolve, reject)
    }
    #changeState(state, value) {
        if (this.#state !== "pending") return
        this.#state = state
        this.#value = value
    }
}

代码优化

现在我们发现在我们的代码中还存在着一些硬编码的部分，如状态不应该直接使用字符串而是需要使用变量存起来，这样如果以后状态的名称发生改变，我们也就只需要更改变量的内容

javascript">class MyPromise {
    #state = "pending"
    #value = null
    static #PENDING = "pending"
    static #FULFILLED = "fulfilled"
    static #REJECTED = "rejected"
    constructor(executor) {
        const resolve = (data) => {
            this.#changeState(MyPromise.#FULFILLED, data)
        }
        const reject = (reason) => {
            this.#changeState(MyPromise.#REJECTED, reason)
        }
        executor(resolve, reject)
    }
    #changeState(state, value) {
        if (this.#state !== MyPromise.#PENDING) return
        this.#state = state
        this.#value = value
    }
}

我们将三种状态用变量存起来，因为三个状态只会在内部使用而且每个实例都会拥有这三个状态，所以我将其定义为静态私有成员

回调函数中抛出错误

现在大部分问题我们都解决了，但是在回调函数中抛出错误的情况我们并没有处理，在Promise中如果回调函数中抛出了错误会被Promise内部捕获到，直接reject，那么我们的代码就可以这么写

javascript">constructor(executor) {
    const resolve = (data) => {
        this.#changeState(MyPromise.#FULFILLED, data)
    }
    const reject = (reason) => {
        this.#changeState(MyPromise.#REJECTED, reason)
    }
    try {
        executor(resolve, reject)
    } catch (error) {
        reject(error)
    }
}

至此我们就将MyPromise的构造器部分完成了

then

在PromiseA+规范中通篇都在说什么是Promise，简单地说就是Promise可以是一个对象或者是函数，但无论是什么都必须要有then方法，如果有then方法那就是Promise
所以then方法是Promise中的核心，同时也是手写Promise中最难的一部分，如果能将then方法手写出来那整个Promise就可以算是大部分完成了
我们回忆一下Promise中的then方法，发现then方法会传入两个参数，一个是成功时的回调函数，一个是失败时的回调函数，那我们可以这么定义

javascript">class MyPromise {
    then(onFulfilled, onRejected) {
        return new MyPromise((resolve, reject) => {
        })
    }
}

因为then方法是每个实例都拥有并且用到的，所以我们将其定义为成员方法，为了实现Promise的链式调用所以then方法必须返回一个Promise，那么在这个返回的Promise中，我们究竟该做些什么呢

onFulfilled和onRejected的调用时机

onFulfilled和onRejected什么时候调用，这个问题很好解决，依据当前Promise的状态判断是调用onFulfilled还是onRejected

javascript">then(onFulfilled, onRejected) {
    return new MyPromise((resolve, reject) => {
        if (this.#state === MyPromise.#FULFILLED) onFulfilled(this.#value)
        if (this.#state === MyPromise.#REJECTED) onRejected(this.#value)
    })
}

这么写似乎并没有什么问题，那我们来测试一下

javascript">let p1 = new MyPromise((resolve, reject) => {
    resolve(123)
})
let p2 = new MyPromise((resolve, reject) => {
    setTimeout(() => {
        resolve(456)
    }, 1000)
})
p1.then(data => {
    console.log(data)
})
p2.then(data => {
    console.log(data)
})

结果
看得出来，p1成功运行了，但p2似乎有点问题，因为p2在运行到then的时候p2的状态还是pending，p2的状态会在一秒钟后才改变，但then方法早在这之前就调用了，所以为了避免这种情况，我们需要在状态改变的时候再次调用then方法

异步then

再次调用then方法说起来并不精确，我们其实真正想要的并不是调用then方法，而是想要在状态改变的时候调用onFulfiled或者onRejected，那么第一个问题就来了，我们在哪里能知道状态什么时候被改变了？答案是changeState
changeState是用来改变当前实例的状态的函数，当它第一次运行时状态肯定被改变，我们只需要在这里调用onFulfilled或者onRejected，但是有一个新问题，这两个回调函数都是直接传入then中的，我们无法在changeState中拿到这两个函数，那该怎么办呢？我们可以用一个中间变量存储

javascript">class MyPromise {
    #handler = {}
    #changeState(state, value) {
        if (this.#state !== MyPromise.#PENDING) return
        this.#state = state
        this.#value = value
        if (this.#state === MyPromise.#FULFILLED) this.#handler.onFulfilled(this.#value)
        else if (this.#state === MyPromise.#REJECTED) this.#handler.onRejected(this.#value)
    }
    then(onFulfilled, onRejected) {
        return new MyPromise((resolve, reject) => {
            if (this.#state === MyPromise.#FULFILLED) onFulfilled(this.#value)
            else if (this.#state === MyPromise.#REJECTED) onRejected(this.#value)
            else this.#handler = {
                onFulfilled,
                onRejected,
                resolve,
                reject
            }
        })
    }
}

这样问题就解决了，但这里面的重复代码有点多，我们可以将其封装成一个函数

javascript">class MyPromise {
    #changeState(state, value) {
        if (this.#state !== MyPromise.#PENDING) return
        this.#state = state
        this.#value = value
        this.#run()

    }
    then(onFulfilled, onRejected) {
        return new MyPromise((resolve, reject) => {
            this.#handler = {
                onFulfilled,
                onRejected,
                resolve,
                reject
            }
            this.#run()
        })
    }
    #run() {
        if (this.#state === MyPromise.#FULFILLED) {
            this.#handler.onFulfilled(this.#value)
        }
        else if (this.#state === MyPromise.#REJECTED) {
            this.#handler.onRejected(this.#value)
        }
    }

}

我们封装了一个run函数，这个函数专门用来执行then的回调，我们还是用上面那个代码测试
结果
至此异步then问题解决

多个then

有时我们会在一个实例上多次调用then方法，在实例的状态改变后这些then方法的回调函数应该继续执行，但我们的代码却并没有实现
多个then就意味着handler不是一个对象而是一个数组，run方法也不再调用一个handler，而是遍历handlers，将对应状态的回调函数全都取出来执行

javascript">class MyPromise {
    #handlers = []
    then(onFulfilled, onRejected) {
        return new MyPromise((resolve, reject) => {
            this.#handlersPush(onFulfilled, onRejected, resolve, reject)
            this.#run()
        })
    }
    #run() {
        if (this.#state === MyPromise.#PENDING) return
        while (this.#handlers.length > 0) {
            const handler = this.#handlers.shift()
            if (this.#state === MyPromise.#FULFILLED) {
                handler.onFulfilled(this.#value)
            }
            else if (this.#state === MyPromise.#REJECTED) {
                handler.onRejected(this.#value)
            }
        }
    }
    #handlersPush(onFulfilled, onRejected, resolve, reject) {
        this.#handlers.push({
            onFulfilled,
            onRejected,
            resolve,
            reject
        })
    }
}

我们封装了一个辅助函数用于向handlers放入回调，在run中我们会一直在handlers里取出回调执行，我们使用以下代码测试

javascript">let p1 = new MyPromise((resolve, reject) => {
    resolve(123)
})
p1.then(data => {
    console.log("第一个then" + data)
})
p1.then(data => {
    console.log("第二个then" + data)
})

结果
至此，我们的Promise如下

javascript">class MyPromise {
    #state = "pending"
    #value = null
    static #PENDING = "pending"
    static #FULFILLED = "fulfilled"
    static #REJECTED = "rejected"
    #handlers = []
    constructor(executor) {
        const resolve = (data) => {
            this.#changeState(MyPromise.#FULFILLED, data)
        }
        const reject = (reason) => {
            this.#changeState(MyPromise.#REJECTED, reason)
        }
        try {
            executor(resolve, reject)
        } catch (error) {
            reject(error)
        }
    }
    #changeState(state, value) {
        if (this.#state !== MyPromise.#PENDING) return
        this.#state = state
        this.#value = value
        this.#run()

    }
    then(onFulfilled, onRejected) {
        return new MyPromise((resolve, reject) => {
            this.#handlersPush(onFulfilled, onRejected, resolve, reject)
            this.#run()
        })
    }
    #run() {
        if (this.#state === MyPromise.#PENDING) return
        while (this.#handlers.length > 0) {
            const handler = this.#handlers.shift()
            if (this.#state === MyPromise.#FULFILLED) {
                handler.onFulfilled(this.#value)
            }
            else if (this.#state === MyPromise.#REJECTED) {
                handler.onRejected(this.#value)
            }
        }
    }
    #handlersPush(onFulfilled, onRejected, resolve, reject) {
        this.#handlers.push({
            onFulfilled,
            onRejected,
            resolve,
            reject
        })
    }
}

因为内容过多，所以我将文章分为两篇，接下来的部分请看我的这篇文章
js手写Promise（下）


http://www.niftyadmin.cn/n/5370435.html

相关文章

linux系统lvs命令的使用

linux系统lvs命令的使用

Lvs命令 LVS ipvsadm 命令的使用LVS-server安装lvs管理软件命令选项 LVS ipvsadm 命令的使用 LVS-server安装lvs管理软件 yum -y install ipvsadm 程序包：ipvsadm（LVS管理工具） 主程序：/usr/sbin/ipvsadm 规则保存工具&#x…
阅读更多...
使用深度学习对视频进行分类

使用深度学习对视频进行分类

目录 加载预训练卷积网络 加载数据 将帧转换为特征向量 准备训练数据 创建 LSTM 网络 指定训练选项 训练 LSTM 网络 组合视频分类网络 使用新数据进行分类 辅助函数 此示例说明如何通过将预训练图像分类模型和 LSTM 网络相结合来创建视频分类网络。 要为视频…
阅读更多...
Linux大集合

Linux大集合

Linux Linux是什么？ Linux是一套免费使用和自由传播的类Unix操作系统，是一个基于POSIX和UNIX的多用户、多任务、 支持多线程和多CPU的操作系统。它能运行主要的UNIX工具软件、应用程序和网络协议。它支持32位和 64位硬件。 Linux内核 是一个Linux系统…
阅读更多...
CTFshow web(php命令执行 45-49）

CTFshow web(php命令执行 45-49）

基础知识&#xff1a; 1.绕过cat使用&#xff1a; tac more less head tac tail nl od(二进制查看) vi vim sort uniq rev 2.绕过空格用&#xff1a; %09 <> ${IFS} $IFS$ {cat,fl*} %20 注&#xff1a; %09 ##&#xff08;Tab&#xff09; %20 ##&#xff08;spa…
阅读更多...
传输层协议 ——— TCP协议

传输层协议 ——— TCP协议

TCP协议 TCP协议谈谈可靠性为什么网络中会存在不可靠&#xff1f;TCP协议格式TCP如何将报头与有效载荷进行分离&#xff1f;序号与确认序号 确认应答机制&#xff08;ACK&#xff09;超时重传机制连接管理机制三次握手四次挥手 流量控制滑动窗口拥塞控制延迟应答捎带应答面向字…
阅读更多...
仰暮计划|“第一次看到电视上播放的电影，那种震撼和喜悦仍然留在我的记忆中”

仰暮计划|“第一次看到电视上播放的电影，那种震撼和喜悦仍然留在我的记忆中”

首 我是陈香妹&#xff0c;家在浙江省温州市瑞安市湖岭镇。 在上个世纪&#xff0c;我亲身经历过许多动荡和改变。那是一个充满希望和艰辛的时代&#xff0c;我曾见证了许多社会的变革和人们的奋斗。 01. 上世纪50年代&#xff0c;我还是一个十多岁的小姑娘&#xff0c;正处…
阅读更多...
Android 自定义BaseActivity

Android 自定义BaseActivity

直接上代码&#xff1a; BaseActivity代码&#xff1a; package com.example.custom.activity;import android.annotation.SuppressLint; import android.app.Activity; import android.content.pm.ActivityInfo; import android.os.Bundle; import android.os.Looper; impor…
阅读更多...
五官行为检测（表情基）解决方案提供商

五官行为检测（表情基）解决方案提供商

随着人工智能技术的日益成熟&#xff0c;情感识别与行为分析在企业界的应用逐渐广泛。美摄科技作为业内领先的五官行为检测&#xff08;表情基&#xff09;解决方案提供商&#xff0c;致力于为企业提供高效、精准的情感识别与行为分析服务。 美摄科技的五官行为检测&#xff0…
阅读更多...
最新文章

Copyright @ 2022~2023