面试题：手撕PromiseA+规范（核心功能）

缺乏、安全感 2022-11-06 08:53 159阅读 0赞

**注释应该还可以：**

(function () { 
        // 开启严格模式
        "use strict"
    
        function Promise(executor) { 
            var self = this,
                change;
    
            // 传进来的参数不是function 直接报错
            if (typeof executor !== 'function') throw new TypeError(`${ executor} must be an function`);
            // 不能通过call/apply/bind 改变this ,this不是promise的实例 直接报错
            if (!(self instanceof Promise)) throw new TypeError('undefined is not a promise');
    
            // promise 状态 默认等待状态
            self.state = 'padding';
            // promise 结果 默认undefined
            self.result = undefined;
            // 成功回调数组
            self.onfufiledCallback = [];
            // 失败回调数组
            self.onrejectedCallback = [];
    
            change = function change(state, result) { 
                // 判断当前promise是否为padding状态，状态一旦修改就不能再修改
                if (self.state !== 'padding') return;
                self.state = state;
                self.result = result;
    
                // 判断一下当前成功回调数组、失败回调数组 中是否存在待执行的方法，存在状态修改的时候拿出来执行
                var callbacks = state === 'success' ? self.onfufiledCallback : self.onrejectedCallback,
                    len = callbacks.length,
                    i = 0,
                    callback;
                for (; i < len; i++) { 
                    callback = callbacks[i];
                    if (typeof callback === 'function') callback(result);
                }
    
            }
            try { 
                // 同步代码执行
                executor(function resolve(result) { 
                    change('success', result)
                }, function reject(resaon) { 
                    change('fail', resaon)
                })
            } catch (error) { 
                // 程序报错 promise状态也为失败
                change('fail', error)
            }
    
        }
    
        // 判断是否为类promise ,有.then方法返回true
        function isPromise(x) { 
            if (x == null) return false;
            if (/^('object'|'function')$/i.test(typeof x)) { 
                if (typeof x.then === 'function') { 
                    return true;
                }
            }
            return false;
        }
    
        // 统一返回处理结果
        function handler(promiseNew, x, resolve, reject) { 
            if (promiseNew === x) throw new TypeError('Chaining cycle detected for promise #<Promise>');
            if (isPromise(x)) { 
                try { 
                    // 实现then链
                    x.then(resolve, reject)
                } catch (err) { 
                    reject(err)
                }
            }
            resolve(x)
    
        }
        // promise原型上成功方法
        Promise.resolve = function resolve(result) { 
            return new Promise(function (resolve) { 
                resolve(result)
            })
        }
        // promise原型上失败方法
        Promise.reject = function reject(reason) { 
            return new Promise(function (_, reject) { 
                reject(reason)
            })
        }
        Promise.all = function all(ary) { 
            var newPromise,
                results = [],
                n = 0;
    
            // 判断传进来的参数不是数组 抛出异常
            if (!Array.isArray(ary)) throw new TypeError(`${ ary} is not iterable`);
            // 处理promise数组
            ary.map(item => { 
                // 判断当前项不是promise 默认返回一个成功的promise
                if (!isPromise(item)) { 
                    Promise.resolve(item);
                }
                return item;
            })
    
            // .all执行返回的新promise实例
            newPromise = new Promise(function (resolve, reject) { 
                ary.forEach((promise, index) => { 
                    promise.then(function (result) { 
                        n++;
                        // 使用index方式不用push往数组中放 是为了保证results中的返回结果跟传进来的结果保持一致
                        results[index] = result;
                        // 全部处理成功
                        if (n >= ary.length) resolve(results);
    
                    }).catch(function (reason) { 
                        reject(reason)
                    })
                })
            })
            return newPromise;
    
        }
        // 原型重定向
        Promise.prototype = { 
            then: function then(onfufiled, onrejected) { 
                let self = this,
                    promiseNew,
                    x;
                // onfufiled, onrejected 不是方法默认 给他设置一个方法
                // 只传一个参数的时候 默认给他设置一个参数， 是为了加上穿透性
                if (typeof onfufiled !== "function") { 
                    onfufiled = function onfufiled(result) { 
                        return result;
                    };
                }
    
                if (typeof onrejected !== "function") { 
                    onrejected = function onrejected(reason) { 
                        throw reason;
                    };
                }
                // .then方法 返回值若是一个promise实例 则状态为返回的promise的状态
                // 返回值若不是一个promise实例 则代码执行不报错即为成功
                // 统一处理.then逻辑
                promiseNew = new Promise(function (resolve, reject) { 
                    switch (self.state) { 
                        case 'success':
                            setTimeout(function () { 
                                // 成功 失败统一处理
                                // 如果代码执行异常 返回的promise实例状态直接变为失败
                                try { 
                                    x = onfufiled(self.result);
                                    handler(promiseNew, x, resolve, reject);
                                } catch (err) { 
                                    reject(err)
                                }
                            }, 0)
                            break;
                        case 'fail':
                            setTimeout(function () { 
                                // 成功 失败统一处理
                                // 如果代码执行异常 返回的promise实例状态直接变为失败
                                try { 
                                    x = onrejected(self.result);
                                    handler(promiseNew, x, resolve, reject);
                                } catch (err) { 
                                    reject(err)
                                }
                            }, 0)
                            break;
                        default:
                            // promise为padding状态是需要将onfufiled, onrejected存起来
                            // 待promise状态修改时执行
                            // 利用 柯理化函数的思想，在函数外边包一层 预处理的方式拿到函数执行返回结果
                            self.onfufiledCallback.push(function (result) { 
                                try { 
                                    x = onfufiled(result);
                                    handler(promiseNew, x, resolve, reject);
                                } catch (err) { 
                                    reject(err);
                                }
                            });
                            self.onrejectedCallback.push(function (result) { 
                                try { 
                                    x = onrejected(result);
                                    handle(promiseNew, x, resolve, reject);
                                } catch (err) { 
                                    reject(err)
                                }
                            });
                        // self.onfufiledCallback.push(function (resaon) { 
                        // try { 
                        // x = onrejected(result);
                        // handler(promiseNew, x, resolve, reject);
                        // } catch (err) { 
                        // reject(err);
                        // }
                        // });
    
                    }
                })
                return promiseNew;
    
            },
            catch: function (rejected) { 
                return this.then(null, rejected)
            },
            finally: function () { 
    
            }
        }
        // 判断是否为浏览器环境下
        if (typeof window !== 'undefined') window.Promise = Promise;
        // 判断是否支持commonJS规范
        if (typeof modules === 'object' && modules.exports === 'object') modules.exports = Promise
    
    })();
    
    // 测试代码
    var a = Promise.resolve('11111')
    var b = Promise.reject('6666')
    // a.then(result => { 
    // console.log(result);
    // }, reason => { 
    // console.log(reason);
    // }).then(result => { 
    // console.log('8765432');
    // });
    // b.then(null, reason => { 
    // console.log(reason)
    // })
    Promise.all([a, b])
        .then(result => { 
            console.log(result);
        }).catch(function (res) { 
            console.log(res);
        });

发表评论取消回复

表情：

评论列表（有 0 条评论，159人围观）

还没有评论，来说两句吧...

相关阅读

相关 2024华为OD面试手撕真题【完美答案】

假设共有 questionsCount 道题，题目编号从 1 到 questionsCount。现给出每个考生的答对题目的编号，格式如1 3，表示答对第1到3题；9 9表...

末蓝、/ 2024年04月20日 14:14/ 0 赞/ 105 阅读

相关华为面试手撕真题【换零钱】

> 给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。计算并返回可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组

柔情只为你懂/ 2023年09月26日 23:54/ 0 赞/ 124 阅读

相关华为面试手撕真题【字符串的排列】

> 输入一个字符串，打印出该字符串中字符的所有排列。 > > 你可以以任意顺序返回这个字符串数组，但里面不能有重复元素。典型的全排列问题，根据字符串排列的特点，考虑深度优

不念不忘少年蓝@/ 2023年09月26日 23:46/ 0 赞/ 22 阅读

相关手撕面试题

手撕面试题 ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9n

╰半夏微凉°/ 2023年01月23日 12:47/ 0 赞/ 53 阅读

相关信条｜手撕吊打面试官系列面试题

必备面试题 js基础 1. 用js打印一个乘法表这一题面试官考察的是你关于js的打印相关基础api的熟悉程度，以及基本的数学常识，送分题 consol

ゝ一世哀愁。/ 2022年12月21日 03:11/ 0 赞/ 201 阅读

相关【信条】手撕吊打面试官系列面试题

必备面试题 js基础 1. 用js打印一个乘法表这一题面试官考察的是你关于js的打印相关基础api的熟悉程度，以及基本的数学常识，送分题 consol

深藏阁楼爱情的钟/ 2022年12月17日 08:42/ 0 赞/ 165 阅读

相关 30道高频JS手撕面试题

前言最近在准备面试，刚好利用几天的时间系统的整理了下JS经常考的手撕题类型。在这里，以脑图的形式带大家手撕这篇文章里的所有题（带注释）。想领取脑图的关注前端时光

深碍√TFBOYSˉ_/ 2022年12月11日 03:17/ 0 赞/ 192 阅读

相关 [JavaScript]根据PromiseA+规范手写Promise

一、Promise的声明首先呢，`Promise`肯定是一个类，我们就用`class`来声明。 • 由于 `new Promise((resolve, reject

今天药忘吃喽~/ 2022年12月11日 03:10/ 0 赞/ 147 阅读

相关面试题：手撕PromiseA+规范（核心功能）

注释应该还可以： (function () { // 开启严格模式 "use strict" functi

缺乏、安全感/ 2022年11月06日 08:53/ 0 赞/ 160 阅读

相关手撕遵循 Promise/A+ 规范的 Promise

> 相比于回调函数，Promise 解决了 “回调地狱” 和 “信任问题” 等痛点，并且大大提高了代码的可读性。在现代前端开发中，Promise 几乎成了处理异步的首选（虽然还

谁践踏了优雅/ 2022年01月20日 05:33/ 0 赞/ 223 阅读