17 # 静态方法 resolve 和 reject 的区别

简介: 17 # 静态方法 resolve 和 reject 的区别

Promise.resolve 快速创建一个成功的promise

Promise.reject 快速创建一个失败的promise

区别:resolve 会等待里面的 promise 执行完毕,reject 不会有等待效果

下面实现静态方法 resolve 和 reject:需要进行递归解析 resolve 中的参数,直到这个值是普通值

// promise 就是一个类
// 1. promise 有三个状态:成功态(resolve) 失败态(reject) 等待态(pending)(又不成功又不失败)
// 2. 用户自己决定失败的原因和成功的原因,成功和失败也是用户定义的
// 3. promise 默认执行器立即执行
// 4. promise 的实例都拥有一个 then 方法,一个参数是成功的回调,另一个是失败的回调
// 5. 如果执行函数时发生了异常也会执行失败的逻辑
// 6. 如果 promise 一旦成功就不能失败,反之亦然,只有等待态的时候才能去更新状态
const RESOLVE = "RESOLVE"; // 成功态
const REJECT = "REJECT"; // 失败态
const PENDING = "PENDING"; // 等待态
// 解析 promise:所有的promise需要兼容,比如 bluebird q es6-promise
const resolvePromise = (promise2, x, resolve, reject) => {
    // 处理一下循环引用(自己等待自己的错误实现),这个时候我们用一个类型错误结束掉 promise。
    if (promise2 === x) {
        reject(new TypeError("Chaining cycle detected for promise #<Promise>"));
    }
    // 用于防止走成功又走失败
    let called;
    // 后续的条件要严格判断 保证代码能和别的库一起使用
    if ((typeof x === "object" && x !== null) || typeof x === "function") {
        // 要继续判断是否是一个promise
        try {
            // x.then 取值时可能会报错,需要捕获异常
            let then = x.then;
            // then 是个函数我们就认为是promise
            if (typeof then === "function") {
                // 下面为什么不写成 x.then 的原因,可能第二次取出报错,直接写成 then.call(x)
                // 根据 promise 的状态决定是成功还是失败
                then.call(
                    x,
                    (y) => {
                        if (called) return;
                        called = true;
                        // 递归解析
                        resolvePromise(promise2, y, resolve, reject);
                    },
                    (e) => {
                        if (called) return;
                        called = true;
                        reject(e);
                    }
                );
            } else {
                resolve(x);
            }
        } catch (e) {
            // 防止失败了再次进入成功
            if (called) return;
            called = true;
            reject(e);
        }
    } else {
        resolve(x);
    }
};
class KaimoPromise {
    constructor(executor) {
        this.status = PENDING;
        // value 是任意合法的 Javascript 值,(包括 undefined,thenable, promise)。
        this.value = undefined;
        // reason 是表示 promise 为什么被 rejected 的值
        this.reason = undefined;
        // 存放成功回调
        this.onResolveCallbacks = [];
        // 存放失败回调
        this.onRejectCallbacks = [];
        let resolve = (value) => {
            // 如果 value 是 KaimoPromise 的实例,需要进行递归解析 resolve 中的参数,直到这个值是普通值
            if (value instanceof KaimoPromise) {
                return value.then(resolve, reject);
            }
            if (this.status === PENDING) {
                this.value = value;
                this.status = RESOLVE;
                this.onResolveCallbacks.forEach((fn) => fn());
            }
        };
        let reject = (reason) => {
            if (this.status === PENDING) {
                this.reason = reason;
                this.status = REJECT;
                this.onRejectCallbacks.forEach((fn) => fn());
            }
        };
        try {
            // 立即执行
            executor(resolve, reject);
        } catch (error) {
            // 处理错误异常
            console.log("inner---->", error);
            reject(error);
        }
    }
    // 1. promise 成功和失败的回调的返回值可以传递到外层的下一个 then
    // 2. promise 返回值情况
    //  2.1. 如果返回的是普通的值的话:传递到下一次的成功中(不是错误也不是 promise 就是普通值)
    //  2.2. 如果返回的是错误的情况:一定会走到下一次的失败中
    //  2.3. 如果返回的是 promise 的情况:会采用 promise 的状态,决定下一步是走成功还是失败
    // 3. 错误处理:如果离自己最近的 then 没有错误处理(没有写错误函数)会向下找
    // 4. 每次执行完 `promise.then` 方法后返回的都是一个新的 promise (promise 一旦成功或者失败都不能去修改状态)
    // promise 必须提供 then 方法来存取它当前或最终的值或者原因。
    // then 接收两个参数:onFulfilled 和 onRejected
    then(onFulfilled, onRejected) {
        onFulfilled = typeof onFulfilled === "function" ? onFulfilled : (v) => v;
        onRejected =
            typeof onRejected === "function"
                ? onRejected
                : (err) => {
                      throw err;
                  };
        // 实现链式调用
        let promise2 = new KaimoPromise((resolve, reject) => {
            if (this.status === RESOLVE) {
                // setTimeout 处理 promise2 没有初始化的问题, 需要等 executor 执行完
                setTimeout(() => {
                    // try catch 无法捕获异步代码,所以需要在 promise2 里面也加 try catch
                    try {
                        let x = onFulfilled(this.value);
                        // x 可能是一个 promise
                        resolvePromise(promise2, x, resolve, reject);
                    } catch (e) {
                        reject(e);
                    }
                }, 0);
            }
            if (this.status === REJECT) {
                setTimeout(() => {
                    try {
                        let x = onRejected(this.reason);
                        resolvePromise(promise2, x, resolve, reject);
                    } catch (e) {
                        reject(e);
                    }
                }, 0);
            }
            // 下面是异步的,可以不加setTimeout,统一一下加了一下
            if (this.status === PENDING) {
                this.onResolveCallbacks.push(() => {
                    setTimeout(() => {
                        try {
                            let x = onFulfilled(this.value);
                            resolvePromise(promise2, x, resolve, reject);
                        } catch (e) {
                            reject(e);
                        }
                    }, 0);
                });
                this.onRejectCallbacks.push(() => {
                    setTimeout(() => {
                        try {
                            let x = onRejected(this.reason);
                            resolvePromise(promise2, x, resolve, reject);
                        } catch (e) {
                            reject(e);
                        }
                    }, 0);
                });
            }
        });
        return promise2;
    }
    catch(errCallback) {
        return this.then(null, errCallback);
    }
    static resolve(data) {
        return new KaimoPromise((resolve, reject) => {
            resolve(data);
        });
    }
    static reject(reason) {
        return new KaimoPromise((resolve, reject) => {
            reject(reason);
        });
    }
}
// promise 延迟对象 规范测试入口
KaimoPromise.defer = KaimoPromise.deferred = function () {
    let dfd = {};
    dfd.promise = new KaimoPromise((resolve, reject) => {
        dfd.resolve = resolve;
        dfd.reject = reject;
    });
    return dfd;
};
module.exports = KaimoPromise;

测试:

const KaimoPromise = require("./17/kaimo-promise.js");
KaimoPromise.resolve("kaimo666").then((data) => {
    console.log("KaimoPromise.resolve--->", data);
});
KaimoPromise.reject("kaimo777").then(
    (data) => {
        console.log("KaimoPromise.reject--->data", data);
    },
    (err) => {
        console.log("KaimoPromise.reject--->err", err);
    }
);
KaimoPromise.resolve(
    new KaimoPromise((resolve, reject) => {
        setTimeout(() => {
            resolve("kaimo313");
        }, 1000);
    })
).then((data) => {
    console.log("KaimoPromise.resolve--->", data);
});

目录
相关文章
|
机器学习/深度学习
智能体DS-Agent基于案例推理,让GPT-4数据科学任务接近100%
【4月更文挑战第20天】DS-Agent是结合案例推理(CBR)和大型语言模型的新研究,旨在提升自动化数据科学任务效率。通过自动迭代管道,它能理解任务、构建模型并优化性能。在开发阶段,成功率高达100%,部署阶段平均提高36%的一次通过率,降低成本,使开源LLMs也能高效处理数据科学任务。然而,LLMs的生成问题和资源限制仍是挑战。论文链接:https://arxiv.org/pdf/2402.17453.pdf
383 4
|
设计模式 开发框架 监控
精准解读桥接模式-用桥接模式构建可扩展的软件系统
桥接模式是一种设计模式,旨在将抽象和实现部分分离,使它们可以独立地变化。这种模式的目的是提高系统的灵活性和可扩展性。桥接模式的主要思想是将抽象和实现通过一个桥接类连接起来,从而实现它们的解耦。在这种模式中,抽象部分可以根据需要进行扩展,而实现部分可以自由地变化,而不影响彼此。桥接模式在处理多个独立变化的维度、解耦继承关系、处理平台差异和扩展现有系统等方面具有广泛的应用领域。通过使用桥接模式,可以提高系统的可维护性和可扩展性,使系统更加灵活和适应变化。通过桥接模式,将系统中的抽象部分与实现部分解耦,从而...
430 0
精准解读桥接模式-用桥接模式构建可扩展的软件系统
|
存储 Kubernetes 调度
k8s教程(pod篇)-DaemonSet(每个node上只调度一个pod)
k8s教程(pod篇)-DaemonSet(每个node上只调度一个pod)
401 0
|
网络性能优化 网络架构 网络协议
|
9月前
|
机器学习/深度学习 数据采集 算法
机器学习在生物信息学中的创新应用:解锁生物数据的奥秘
机器学习在生物信息学中的创新应用:解锁生物数据的奥秘
766 36
|
存储 JSON 数据格式
Python教程:json中load和loads的区别
【7月更文挑战第17天】在Python的`json`模块中, `load`与`loads`函数均用于JSON至Python对象的转换, 区别在于: - **`loads`**处理JSON格式的**字符串** 其中`data.json`文件内容为`{&quot;name&quot;: &quot;Bob&quot;, &quot;age&quot;: 30}`。 简而言之, `loads`用于字符串, 而`load`用于文件对象。根据数据来源选择合适的方法。
427 5
|
SQL API Python
`bandit`是一个Python静态代码分析工具,专注于查找常见的安全漏洞,如SQL注入、跨站脚本(XSS)等。
`bandit`是一个Python静态代码分析工具,专注于查找常见的安全漏洞,如SQL注入、跨站脚本(XSS)等。
Java中的枚举类型详解:应用与最佳实践
Java中的枚举类型详解:应用与最佳实践
|
JavaScript 前端开发 程序员
vue-element-admin 运行并且打包部署
vue-element-admin 运行并且打包部署
453 0
|
存储 缓存 iOS开发
Vue3+cropperjs 实现图片裁剪功能
Vue3+cropperjs 实现图片裁剪功能