手撕promise

最新推荐文章于 2023-01-30 16:26:43 发布
最新推荐文章于 2023-01-30 16:26:43 发布
阅读量680 收藏
点赞数
分类专栏： 前端 文章标签： javascript 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47886687/article/details/121590684
版权

promise的特点

1.创建时必须传入一个函数,否则会报错
2.会给传入的函数设置两个回调函数
3. 刚创建的promise对象状态是pending
4.状态一旦发生改变就不可再次改变
5.可以通过then来监听状态的改变
6.如果添加监听时状态已经改变,立即执行监听的回调
7.如果添加监听时状态还未改变,那么状态改变时候再执行监听回调
8.同一个promise对象可以添加多个then监听,状态改变时所有的监听按照添加顺序执行
9.then方法每次执行完毕都会返回一个新的promise对象
10.上一个promise对象的then可以给下一个promise的then传递数据
11.无论上一个是在成功的回调还是失败的回调传递的参数都会传递给下一个成功的回调
12.如果上一个传递的是promise对象，那么传给下一个的成果还是失败由传递的promise状态决定
13.后一个then可以捕捉前一个then的异常
14.catch方法就是then方法的语法糖then（undefined，function(){}）

一、创建时必须传入一个函数,否则会报错

 <script>
        //自己创建的promise类
        class MyPromise {
            constructor(handle) {
                //1.判斷是否传入了一个函数,如果没有传入就抛出一个异常
                if (!this.isFunction(handle)) {
                    throw new Error('请传入一个函数')
                }

            }
            isFunction(fn) {
                return typeof fn === 'function'
            }

        }
        // let promise = new MyPromise()//错误示范,会抛出报错
        let promise = new MyPromise(function () { })
    </script>

在这里插入图片描述

二、会给传入的函数设置两个回调函数

 <script>
        class MyPromise {
            constructor(handle) {
                //1.判斷是否传入了一个函数,如果没有传入就抛出一个异常
                if (!this.isFunction(handle)) {
                    throw new Error('请传入一个函数')
                }
                //2.给传入的函数设置两个回调函数
                handle(this.resolve, this.reject)//*****新增
            }
            isFunction(fn) {
                return typeof fn === 'function'
            }
            //*****新增
            resolve() {
                console.log('resolve');
            }
            //*****新增
            reject() {
                console.log('reject');
            }

        }
        // let promise = new MyPromise()//错误示范,会抛出报错
        let promise = new MyPromise(function (resolve, reject) {
            //*****新增
            resolve()
            reject()
        })
    </script>

在这里插入图片描述

三、刚创建的promise对象状态是pending

 <script>
        // //****新增,先定义三种状态
        const PENDING = 'pending'
        const FULFILLED = 'fulfilled'
        const REJECTED = 'rejected'
        class MyPromise {
            constructor(handle) {
                //****新增
                // 0.默认状态为等待
                this.state = PENDING
                //1.判斷是否传入了一个函数,如果没有传入就抛出一个异常
                if (!this.isFunction(handle)) {
                    throw new Error('请传入一个函数')
                }
                //2.给传入的函数设置两个回调函数
                handle(this.resolve.bind(this), this.reject.bind(this))//****新增,这里是外部调用,只有window,所以需要将this传入
            }
            isFunction(fn) {
                return typeof fn === 'function'
            }
            resolve() {
                this.state = FULFILLED//****新增
            }
            reject() {
                this.state = REJECTED//****新增

            }

        }
        let promise = new MyPromise(function (resolve, reject) {
            resolve()
            // reject()
        })
        console.log(promise);//****新增
    </script>

在这里插入图片描述

四、状态一旦发生改变就不可再次改变

   <script>
        // 先定义三种状态
        const PENDING = 'pending'
        const FULFILLED = 'fulfilled'
        const REJECTED = 'rejected'
        class MyPromise {
            constructor(handle) {
                // 0.默认状态为等待
                this.state = PENDING
                //1.判斷是否传入了一个函数,如果没有传入就抛出一个异常
                if (!this.isFunction(handle)) {
                    throw new Error('请传入一个函数')
                }
                //2.给传入的函数设置两个回调函数
                handle(this.resolve.bind(this), this.reject.bind(this))
            }
            isFunction(fn) {
                return typeof fn === 'function'
            }
            resolve() {
                //***********新增
                // 4.状态一旦发生改变就不可再次改变
                if (this.state === PENDING) {
                    this.state = FULFILLED
                }
            }
            reject() {
                if (this.state === PENDING) {
                    this.state = REJECTED
                }

            }

        }
        let promise = new MyPromise(function (resolve, reject) {
            resolve()
            // reject()
        })
        console.log(promise);
    </script>

五、通过then来监听状态的改变，如果添加监听时状态已经改变,立即执行监听的回调

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <script>
        // 先定义三种状态
        const PENDING = 'pending'
        const FULFILLED = 'fulfilled'
        const REJECTED = 'rejected'
        class MyPromise {
            constructor(handle) {
                // 0.默认状态为等待
                this.state = PENDING
                //1.判斷是否传入了一个函数,如果没有传入就抛出一个异常
                if (!this.isFunction(handle)) {
                    throw new Error('请传入一个函数')
                }
                //2.给传入的函数设置两个回调函数
                handle(this.resolve.bind(this), this.reject.bind(this))
            }
            //******************新增
            // 5.通过then来监听状态的改变，如果添加监听时状态已经改变,立即执行监听的回调
            then(onResolve, onReject) {
                // (1)判断有无传入成功的函数
                if (this.isFunction(onResolve)) {
                    //(2)状态改变立即调用函数
                    if (this.state === FULFILLED) {
                        onResolve()
                    }
                }
                // (1)判断有无传入失败的函数
                if (this.isFunction(onReject)) {
                    //(2)状态改变立即调用函数
                    if (this.state === REJECTED) {
                        onReject()
                    }
                }


            }
            isFunction(fn) {
                return typeof fn === 'function'
            }
            resolve() {
                // 4.状态一旦发生改变就不可再次改变
                if (this.state === PENDING) {
                    this.state = FULFILLED
                }
            }
            reject() {
                if (this.state === PENDING) {
                    this.state = REJECTED
                }

            }

        }
        let promise = new MyPromise(function (resolve, reject) {
            // resolve()
            reject()
        })
        //******************新增
        promise.then(() => {
            console.log('成功');
        }, () => {
            console.log('失败');
        })
    </script>

</body>

</html>

在这里插入图片描述

参数传递

  <script>
        // 先定义三种状态
        const PENDING = 'pending'
        const FULFILLED = 'fulfilled'
        const REJECTED = 'rejected'
        class MyPromise {
            constructor(handle) {
                // 0.默认状态为等待
                this.state = PENDING
                // 定义变量保存传入的参数************新增
                this.value = undefined
                this.reason = undefined
                //1.判斷是否传入了一个函数,如果没有传入就抛出一个异常
                if (!this.isFunction(handle)) {
                    throw new Error('请传入一个函数')
                }
                //2.给传入的函数设置两个回调函数
                handle(this.resolve.bind(this), this.reject.bind(this))
            }
            // 5.通过then来监听状态的改变，如果添加监听时状态已经改变,立即执行监听的回调
            then(onResolve, onReject) {
                // (1)判断有无传入成功的函数
                if (this.isFunction(onResolve)) {
                    //(2)状态改变立即调用函数
                    if (this.state === FULFILLED) {
                        onResolve(this.value)//********新增变动
                    }
                }
                // (1)判断有无传入失败的函数
                if (this.isFunction(onReject)) {
                    //(2)状态改变立即调用函数
                    if (this.state === REJECTED) {
                        onReject(this.reason)//********新增变动
                    }
                }


            }
            isFunction(fn) {
                return typeof fn === 'function'
            }
            //*****新增变动
            resolve(value) {
                // 4.状态一旦发生改变就不可再次改变
                if (this.state === PENDING) {
                    this.state = FULFILLED
                    this.value = value
                }
            }
            //*****新增变动
            reject(reason) {
                if (this.state === PENDING) {
                    this.state = REJECTED
                    this.reason = reason
                }

            }

        }
        let promise = new MyPromise(function (resolve, reject) {
            resolve('111')//*****新增传参
            // reject('222')//*****新增传参
        })
        promise.then((value) => {
            console.log('成功', value);
        }, (reason) => {
            console.log('失败', reason);
        })
    </script>

在这里插入图片描述

六、如果添加监听时状态还未改变,那么状态改变时候再执行监听回调

 <script>
        // 先定义三种状态
        const PENDING = 'pending'
        const FULFILLED = 'fulfilled'
        const REJECTED = 'rejected'
        class MyPromise {
            constructor(handle) {
                // 0.默认状态为等待
                this.state = PENDING
                // 定义变量保存传入的参数
                this.value = undefined
                this.reason = undefined

                // 定义变量保存监听的函数//***新增
                this.onResolveCallback = null
                this.onRejectCallback = null
                //1.判斷是否传入了一个函数,如果没有传入就抛出一个异常
                if (!this.isFunction(handle)) {
                    throw new Error('请传入一个函数')
                }
                //2.给传入的函数设置两个回调函数
                handle(this.resolve.bind(this), this.reject.bind(this))
            }
            // 5.通过then来监听状态的改变，如果添加监听时状态已经改变,立即执行监听的回调
            then(onResolve, onReject) {
                // (1)判断有无传入成功的函数
                if (this.isFunction(onResolve)) {
                    //(2)状态改变立即调用函数
                    if (this.state === FULFILLED) {
                        onResolve(this.value)
                    }
                }
                // (1)判断有无传入失败的函数
                if (this.isFunction(onReject)) {
                    //(2)状态改变立即调用函数
                    if (this.state === REJECTED) {
                        onReject(this.reason)
                    }
                }


                // 判断状态未改变先储存//***新增
                if (this.state === PENDING) {
                    if (this.isFunction(onResolve)) {
                        this.onResolveCallback = onResolve
                    }
                    if (this.isFunction(onReject)) {
                        this.onRejectCallback = onReject
                    }
                }


            }
            isFunction(fn) {
                return typeof fn === 'function'
            }
            resolve(value) {
                // 4.状态一旦发生改变就不可再次改变
                if (this.state === PENDING) {
                    this.state = FULFILLED
                    this.value = value
                    this.onResolveCallback(this.value)//***新增
                }
            }
            reject(reason) {
                if (this.state === PENDING) {
                    this.state = REJECTED
                    this.reason = reason
                    this.onRejectCallback(this.reason)
                }

            }

        }
        let promise = new MyPromise(function (resolve, reject) {
            //***新增
            setTimeout(() => {
                resolve('111')
            }, 2000)
            // reject('222')
        })
        promise.then((value) => {
            console.log('成功', value);
        }, (reason) => {
            console.log('失败', reason);
        })
    </script>

在这里插入图片描述

七、同一个promise对象可以添加多个then监听,状态改变时所有的监听按照添加顺序执行

 <script>
        // 先定义三种状态
        const PENDING = 'pending'
        const FULFILLED = 'fulfilled'
        const REJECTED = 'rejected'
        class MyPromise {
            constructor(handle) {
                // 0.默认状态为等待
                this.state = PENDING
                // 定义变量保存传入的参数
                this.value = undefined
                this.reason = undefined

                // 定义变量保存监听的函数
                // this.onResolveCallback = null
                // this.onRejectCallback = null
                this.onResolveCallbacks = []//新增
                this.onRejectCallbacks = []//新增
                //1.判斷是否传入了一个函数,如果没有传入就抛出一个异常
                if (!this.isFunction(handle)) {
                    throw new Error('请传入一个函数')
                }
                //2.给传入的函数设置两个回调函数
                handle(this.resolve.bind(this), this.reject.bind(this))
            }
            // 5.通过then来监听状态的改变，如果添加监听时状态已经改变,立即执行监听的回调
            then(onResolve, onReject) {
                // (1)判断有无传入成功的函数
                if (this.isFunction(onResolve)) {
                    //(2)状态改变立即调用函数
                    if (this.state === FULFILLED) {
                        onResolve(this.value)
                    }
                }
                // (1)判断有无传入失败的函数
                if (this.isFunction(onReject)) {
                    //(2)状态改变立即调用函数
                    if (this.state === REJECTED) {
                        onReject(this.reason)
                    }
                }


                // 判断状态未改变先储存
                //*********新增变动
                if (this.state === PENDING) {
                    if (this.isFunction(onResolve)) {
                        // this.onResolveCallback = onResolve
                        this.onResolveCallbacks.push(onResolve)
                    }
                    if (this.isFunction(onReject)) {
                        // this.onRejectCallback = onReject
                        this.onRejectCallbacks(onReject)
                    }
                }


            }
            isFunction(fn) {
                return typeof fn === 'function'
            }
            resolve(value) {
                // 4.状态一旦发生改变就不可再次改变
                if (this.state === PENDING) {
                    this.state = FULFILLED
                    this.value = value
                    // this.onResolveCallback(this.value)
                    this.onResolveCallbacks.forEach(fn => fn(value))
                }
            }
            reject(reason) {
                if (this.state === PENDING) {
                    this.state = REJECTED
                    this.reason = reason
                    // this.onRejectCallback(this.reason)
                    this.onRejectCallback.forEach(fn => fn(value))

                }

            }

        }
        let promise = new MyPromise(function (resolve, reject) {
            resolve('111')

            // reject('222')
        })
        promise.then((value) => {
            console.log('成功', value);
        }, (reason) => {
            console.log('失败', reason);
        }); promise.then((value) => {
            console.log('成功2', value);
        }, (reason) => {
            console.log('失败2', reason);
        }); promise.then((value) => {
            console.log('成功3', value);
        }, (reason) => {
            console.log('失败3', reason);
        });
    </script>

在这里插入图片描述

八、then方法每次执行完毕都会返回一个新的promise对象

   <script>
        // 先定义三种状态
        const PENDING = 'pending'
        const FULFILLED = 'fulfilled'
        const REJECTED = 'rejected'
        class MyPromise {
            constructor(handle) {
                // 0.默认状态为等待
                this.state = PENDING
                // 定义变量保存传入的参数
                this.value = undefined
                this.reason = undefined

                // 定义变量保存监听的函数
                // this.onResolveCallback = null
                // this.onRejectCallback = null
                this.onResolveCallbacks = []
                this.onRejectCallbacks = []
                //1.判斷是否传入了一个函数,如果没有传入就抛出一个异常
                if (!this.isFunction(handle)) {
                    throw new Error('请传入一个函数')
                }
                //2.给传入的函数设置两个回调函数
                handle(this.resolve.bind(this), this.reject.bind(this))
            }
            // 5.通过then来监听状态的改变，如果添加监听时状态已经改变,立即执行监听的回调
            then(onResolve, onReject) {
                // 7.返回新promise**************新增
                return new MyPromise((nextResolve, nextReject) => {
                    // (1)判断有无传入成功的函数
                    if (this.isFunction(onResolve)) {
                        //(2)状态改变立即调用函数
                        if (this.state === FULFILLED) {
                            onResolve(this.value)
                        }
                    }
                    // (1)判断有无传入失败的函数
                    if (this.isFunction(onReject)) {
                        //(2)状态改变立即调用函数
                        if (this.state === REJECTED) {
                            onReject(this.reason)
                            console.log(22222222);
                        }
                    }


                    // 6.判断状态未改变先储存
                    if (this.state === PENDING) {
                        if (this.isFunction(onResolve)) {
                            // this.onResolveCallback = onResolve
                            this.onResolveCallbacks.push(onResolve)
                        }
                        if (this.isFunction(onReject)) {
                            // this.onRejectCallback = onReject
                            this.onRejectCallbacks.push(onReject)
                        }
                    }
                })




            }
            isFunction(fn) {
                return typeof fn === 'function'
            }
            resolve(value) {
                // 4.状态一旦发生改变就不可再次改变
                if (this.state === PENDING) {
                    this.state = FULFILLED
                    this.value = value
                    // this.onResolveCallback(this.value)
                    this.onResolveCallbacks.forEach(fn => fn(value))
                }
            }
            reject(reason) {
                if (this.state === PENDING) {
                    this.state = REJECTED
                    this.reason = reason
                    // this.onRejectCallback(this.reason)
                    this.onRejectCallbacks.forEach(fn => fn(reason))

                }

            }

        }
        let promise = new MyPromise(function (resolve, reject) {
            // resolve('111')
            reject('222')

        })
        // ****************新增
        let p2 = promise.then((value) => {
            console.log('成功', value);
        }, (reason) => {
            console.log('失败', reason);
        });
        console.log(p2, p2 === promise);
    </script>

在这里插入图片描述

九、上一个promise对象的then可以给下一个promise的then传递数据

   <script>
        // 先定义三种状态
        const PENDING = 'pending'
        const FULFILLED = 'fulfilled'
        const REJECTED = 'rejected'
        class MyPromise {
            constructor(handle) {
                // 0.默认状态为等待
                this.state = PENDING
                // 定义变量保存传入的参数
                this.value = undefined
                this.reason = undefined

                // 定义变量保存监听的函数
                // this.onResolveCallback = null
                // this.onRejectCallback = null
                this.onResolveCallbacks = []
                this.onRejectCallbacks = []
                //1.判斷是否传入了一个函数,如果没有传入就抛出一个异常
                if (!this.isFunction(handle)) {
                    throw new Error('请传入一个函数')
                }
                //2.给传入的函数设置两个回调函数
                handle(this.resolve.bind(this), this.reject.bind(this))
            }
            // 5.通过then来监听状态的改变，如果添加监听时状态已经改变,立即执行监听的回调
            then(onResolve, onReject) {
                // 7.返回新promise
                return new MyPromise((nextResolve, nextReject) => {
                    // (1)判断有无传入成功的函数
                    if (this.isFunction(onResolve)) {
                        //(2)状态改变立即调用函数
                        if (this.state === FULFILLED) {
                            //*******新增
                            // 接收返回并传递给下一个promise
                            let result = onResolve(this.value)
                            nextResolve(result)
                        }
                    }
                    // (1)判断有无传入失败的函数
                    if (this.isFunction(onReject)) {
                        //(2)状态改变立即调用函数
                        if (this.state === REJECTED) {
                            let result = onReject(this.reason)
                            nextReject(result)
                        }
                    }


                    // 6.判断状态未改变先储存
                    if (this.state === PENDING) {
                        if (this.isFunction(onResolve)) {
                            // this.onResolveCallback = onResolve
                            //**********新增变动
                            this.onResolveCallbacks.push(() => {
                                let result = onResolve(this.value)
                                nextResolve(result)
                            })
                        }
                        if (this.isFunction(onReject)) {
                            // this.onRejectCallback = onReject
                            this.onRejectCallbacks.push(() => {
                                let result = onReject(this.reason)
                                nextReject(result)
                            })
                        }
                    }
                })




            }
            isFunction(fn) {
                return typeof fn === 'function'
            }
            resolve(value) {
                // 4.状态一旦发生改变就不可再次改变
                if (this.state === PENDING) {
                    this.state = FULFILLED
                    this.value = value
                    // this.onResolveCallback(this.value)
                    this.onResolveCallbacks.forEach(fn => fn(value))
                }
            }
            reject(reason) {
                if (this.state === PENDING) {
                    this.state = REJECTED
                    this.reason = reason
                    // this.onRejectCallback(this.reason)
                    this.onRejectCallbacks.forEach(fn => fn(reason))

                }

            }

        }
        let promise = new MyPromise(function (resolve, reject) {
            // resolve('111')
            // reject('222')
            setTimeout(() => {
                resolve('111')
            }, 2000)

        })
        let p2 = promise.then((value) => {
            console.log('成功', value);
            return '我是p2成功返回'
        }, (reason) => {
            console.log('失败', reason);
            return '我是p2失败返回'
        });

        p2.then((value) => {
            console.log('成功2', value);
        }, (reason) => {
            console.log('失败2', reason);
        });

    </script>

在这里插入图片描述

十、如果上一个传递的是promise对象，那么传给下一个的成果还是失败由传递的promise状态决定

 <script>
        // 先定义三种状态
        const PENDING = 'pending'
        const FULFILLED = 'fulfilled'
        const REJECTED = 'rejected'
        class MyPromise {
            constructor(handle) {
                // 0.默认状态为等待
                this.state = PENDING
                // 定义变量保存传入的参数
                this.value = undefined
                this.reason = undefined

                // 定义变量保存监听的函数
                // this.onResolveCallback = null
                // this.onRejectCallback = null
                this.onResolveCallbacks = []
                this.onRejectCallbacks = []
                //1.判斷是否传入了一个函数,如果没有传入就抛出一个异常
                if (!this.isFunction(handle)) {
                    throw new Error('请传入一个函数')
                }
                //2.给传入的函数设置两个回调函数
                handle(this.resolve.bind(this), this.reject.bind(this))
            }
            // 5.通过then来监听状态的改变，如果添加监听时状态已经改变,立即执行监听的回调
            then(onResolve, onReject) {
                // 7.返回新promise
                return new MyPromise((nextResolve, nextReject) => {
                    // (1)判断有无传入成功的函数
                    if (this.isFunction(onResolve)) {
                        //(2)状态改变立即调用函数
                        if (this.state === FULFILLED) {
                            // 接收返回并传递给下一个promise
                            let result = onResolve(this.value)
                            // 8.判断如果是返回的promise,则等待执行
                            //************新增
                            if (result instanceof MyPromise) {
                                result.then(nextResolve, nextReject)
                            } else {
                                nextResolve(result)
                            }

                        }
                    }
                    // (1)判断有无传入失败的函数
                    if (this.isFunction(onReject)) {
                        //(2)状态改变立即调用函数
                        if (this.state === REJECTED) {
                            let result = onReject(this.reason)
                            //************新增
                            if (result instanceof MyPromise) {
                                result.then(nextResolve, nextReject)
                            } else {
                                nextReject(result)
                            }
                        }
                    }


                    // 6.判断状态未改变先储存
                    if (this.state === PENDING) {
                        if (this.isFunction(onResolve)) {
                            // this.onResolveCallback = onResolve
                            this.onResolveCallbacks.push(() => {
                                let result = onResolve(this.value)
                                //************新增
                                if (result instanceof MyPromise) {
                                    result.then(nextResolve, nextReject)
                                } else {
                                    nextResolve(result)
                                }
                            })
                        }
                        if (this.isFunction(onReject)) {
                            // this.onRejectCallback = onReject
                            this.onRejectCallbacks.push(() => {
                                let result = onReject(this.reason)
                                //*******8新增
                                if (result instanceof MyPromise) {
                                    result.then(nextResolve, nextReject)
                                } else {
                                    nextReject(result)
                                }
                            })
                        }
                    }
                })




            }
            isFunction(fn) {
                return typeof fn === 'function'
            }
            resolve(value) {
                // 4.状态一旦发生改变就不可再次改变
                if (this.state === PENDING) {
                    this.state = FULFILLED
                    this.value = value
                    // this.onResolveCallback(this.value)
                    this.onResolveCallbacks.forEach(fn => fn(value))
                }
            }
            reject(reason) {
                if (this.state === PENDING) {
                    this.state = REJECTED
                    this.reason = reason
                    // this.onRejectCallback(this.reason)
                    this.onRejectCallbacks.forEach(fn => fn(reason))

                }

            }

        }
        let promise = new MyPromise(function (resolve, reject) {
            // resolve('111')
            reject('222')
            // setTimeout(() => {
            //     resolve('111')
            // }, 2000)

        })

        //********新增
        let ppp = new MyPromise((resolve, reject) => {
            // resolve('我是被传递的promise成功')
            reject('我是被传递的promise失败')
            // setTimeout(() => {
            //     resolve('我是被传递的promise成功延时')
            // }, 2000)

        })
        let p2 = promise.then((value) => {
            console.log('成功', value);
            return ppp//*********新增
        }, (reason) => {
            console.log('失败', reason);
            return ppp
        });

        p2.then((value) => {
            console.log('成功2', value);
        }, (reason) => {
            console.log('失败2', reason);
        });

    </script>

在这里插入图片描述

山竹回家了
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Promise：工作流程、常见API、使用方法、手撕Promise、async/await
weixin_42044763的博客
12-28 1934
Promise指定回调函数的方式更加灵活，且支持链式调用，可以解决回调地狱的问题。回调地狱：回调函数嵌套调用，外部回调执行结果是内部函数执行的条件，不便于阅读且不便于异常处理，解决方式就是promise（或async/await）
【js进阶】手撕Promise，一码一解析 包懂！
goodloving的博客
11-21 1837
奥术大
【JavaScript】其实真不难，带你一步一步手撕promise。
qq_53715003的博客
06-27 984
带你手写promise
Promise 大法-手撕promise
Anna_Liqi的博客
05-22 325
1、没有Promise之前的处理 // 以前是使用回调函数 // 这种回调的方式有很多的弊端： // 1> 如果是我们自己缝制的requestData,那么我们在封装的时候必须自己设计好callback名称 // 2> 如果是别人封装的，那我们必须去看别人的源码，看参数等，才能获取到结果 // request.js function requestData(url, successCallback, errorCallback) { // 模拟网络请求 setTimeout(()
promise原理及手写promise
wangyuchen666的博客
11-01 286
1.Promise就是一个类 在执行这个类的时候 需要传递一个执行器进去 执行器会立即执行 2.promise中有三种状态 pending fulfilled rejected 一旦状态确定就不可修改 3.resolve和reject函数是用来更改状态的 4.then方法内部做的事情就判断状态 如果状态是成功 调用成功的回调函数 如果状态是失败 调用失败回调函数 then方法是被定义在原型对象中的 5. then成功回调有一个参数 表示成功之后的值 then失败回调有一个参数 表示失败后的原因 6. .
04手撕promise.js
06-11
04手撕promise.js
面试手撕代码整理
09-29
自己整理的在面试时可能出现的手撕代码题目，例如求一个数的平方根，反转链表，辗转相除法求最大公约数等，希望能提供一些帮助
Python手撕算法Recursion
最新发布
12-25
Python手撕算法Recursion
Python手撕算法RadixSort
12-25
Python手撕算法RadixSort
Python手撕算法QuickSort
12-25
Python手撕算法QuickSort
自己模仿es6的Promise行为实现的Promise
12-20
这是我学习promise异步编程时，通过es6的promise行为模仿出来的promise实现，大致和es6的promise行为一致，具体可以我的这篇关于promise的文章：https://blog.csdn.net/qq_33024515/article/details/85121067
自己封装一个Promise详解，手撕Promise
XuZhiqiang的博客
01-30 616
Promise是JS异步编程中的重要概念，异步抽象处理对象，是目前比较流行Javascript异步编程解决方案之一,本文详细介绍了如何手写一个Promise，即手撕Promise，主要封装了Promise的then、catch、resolve、reject、all、race方法
教你一步一步手撕Promise
老司机的后备箱
09-13 308
手写一个Promise已经是一个常见的手写功能了，虽然实际工作上可能并不会用到。但是在面试时还是会经常被提起的。
手撕 Promise（then 链及 Promise 方法实现）
雪急飞绪博客
02-24 524
Promise 了解 Promise Promise 是一个异步操作返回的对象，用来传递异步操作的消息 可以解决的问题 解决回调地狱问题，不会导致难以维护 合并多个异步请求，节约时间 Promise 的三种状态 Pending 等待态 Fulfilled 成功态 Rejected 失败态 使用 Promise Promise.resolve：将现有对象转为 Promise 对象，这个对象处于 resolve 状态 作用： 改状态 发布事件池子里的方法 Promise.resolve([1, 2
Promise专题之手撕部分实现
qq_36016136的博客
12-26 122
Promise的几个关键问题 一、如何改变promise的状态？ 调用resolve(value)，状态由pending改为resolved 调用reject(value)，状态由pending改为rejected 使用throw抛出异常，状态又pending改为rejected 二、一个promise指定多个成功/失败回调函数，都会调用吗？ 当promise改变为对应状态时都会调用 三、改变promise状态和指定回调函数谁先谁后？ 指定回调函数，主要是then或catch方法的调用，而不是回调
手撕遵循 Promise/A+ 规范的 Promise
weixin_34289744的博客
04-18 305
相比于回调函数，Promise 解决了 “回调地狱” 和 “信任问题” 等痛点，并且大大提高了代码的可读性。在现代前端开发中，Promise 几乎成了处理异步的首选（虽然还有更方便的 async/await，逃）。这篇文章从 Promise 的思想和运行机制入手，深入理解每个 API，最后手写一个遵循 Promise/A+ 规范的 Promise 来。 异步方式 JavaScript 异步方式...
自己动手实现promise
xhjcehust的专栏
07-22 1134
大家都知道，异步编程在web领域内越来越多地运用，但异步回调代码的写法十分恶心，逐层嵌套，不便于阅读。为了解决这个问题，js实现了promise模式，但大多数开发者只知道promise的表面用法，不知其底层实现逻辑。笔者采用PHP实现了自己的promise，借着此过程，与大家分享promise的实现原理。
promise手撕
qq_47735503的博客
03-24 85
1.Promise：2个属性，2个回调，3种状态，4种方法 2个属性： ​ PromiseState(状态)、PromiseResult(return 结果) ​ 2个回调： ​ resolve, reject 3种状态： 未决定的：pending：未曾回调方法 ​ ​ 成功：resolved、fulfilled：回调了resolve() ​ ​ 失败：rejected：回调了rejected() ​ ​ 状态变化： ​
手撕Promise
Ustinian
10-13 139
Promise是ES6新增的引用类型，可以通过new来进行实例化对象。Promise内部包含着异步的操作。这两种方式都会返回一个 Promise 对象。
手撕transformer
09-28
手撕Transformer是指通过自己编写代码实现一个Transformer模型，而不是直接使用现有的Transformer框架或库。手撕Transformer的过程可以帮助我们更好地理解Transformer模型的原理和细节。 要手撕Transformer，首先需要了解Transformer模型的基本结构和原理。Transformer由编码器（Encoder）和解码器（Decoder）组成，每个部分又包含多个层，每个层都有自注意力机制和前馈神经网络。编码器将输入序列映射为一系列的隐藏表示，解码器则通过这些隐藏表示生成目标序列。 下面是手撕Transformer的一些步骤： 1. 定义模型的超参数，如词嵌入的维度、注意力头数、隐藏层的维度等。 2. 编写自注意力机制的代码，包括计算注意力权重、计算上下文向量等。 3. 编写前馈神经网络的代码，包括全连接层和激活函数等。 4. 定义编码器和解码器的代码，将多个自注意力层和前馈神经网络层堆叠起来。 5. 实现模型的前向传播函数，将输入序列通过编码器和解码器得到输出序列。 6. 定义损失函数，常用的是交叉熵损失函数。 7. 实现反向传播函数，计算梯度并更新模型的参数。 8. 使用训练数据对模型进行训练，并调整超参数以提高性能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值