手动实现 Promise

实现：

((root, factory) => {
    if (typeof exports === "object") {
        module.exports = factory();
    } else {
        root.MyPromise = factory();
    }
})(this, function () {
    const PENDING = "pending",
        FULFILLED = "fulfilled",
        REJECTED = "rejected";

    return class MyPromise {
        status = PENDING;
        data = null;
        onResolvedCache = null;
        onRejectedCache = null;
        constructor(executor) {
            const [resolve, reject] = [
                (value) => {
                    if (this.status === PENDING) {
                        this.data = value;
                        this.status = FULFILLED;
                        this.onResolvedCache && this.onResolvedCache();
                    }
                },
                (reason) => {
                    if (this.status === PENDING) {
                        this.data = reason;
                        this.status = REJECTED;
                        this.onRejectedCache && this.onRejectedCache();
                    }
                },
            ];

            try {
                executor(resolve, reject);
            } catch (err) {
                reject(err);
            }
        }

        then(onResolved, onRejected) {
            return new MyPromise((resolve, reject) => {
                const handle = (callback) => {
                    let result = null;
                    if (callback instanceof Function) {
                        result = callback(this.data);
                    }

                    if (result instanceof MyPromise) {
                        result.then(resolve, reject);
                    } else {
                        this.status === FULFILLED
                            ? resolve(this.data)
                            : reject(this.data);
                    }
                };

                switch (this.status) {
                    case PENDING:
                        this.onResolvedCache = () => handle(onResolved);
                        this.onRejectedCache = () => handle(onRejected);
                        break;
                    case FULFILLED:
                        handle(onResolved);
                        break;
                    case REJECTED:
                        handle(onRejected);
                        break;
                }
            });
        }

        catch(onRejected) {
            return this.then(null, onRejected);
        }

        static resolve(data) {
            return new MyPromise((resolve, reject) => {
                if (data instanceof MyPromise) {
                    data.then(resolve, reject);
                } else {
                    resolve(data);
                }
            });
        }

        static reject(reason) {
            return new MyPromise((resolve, reject) => {
                if (reason instanceof MyPromise) {
                    reason.then(resolve, reject);
                } else {
                    reject(reason);
                }
            });
        }

        static all(promises) {
            return new MyPromise((resolve, reject) => {
                let values = [];
                let resolvedCount = 0;
                const promiseTotal = promises.length;
                promises.forEach((promise) => {
                    promise.then(
                        (res) => {
                            values.push(res);
                            resolvedCount++;
                            if (resolvedCount === promiseTotal) {
                                resolve(values);
                            }
                        },
                        (err) => {
                            reject(err);
                        },
                    );
                });
            });
        }

        static race(promises) {
            return new MyPromise((resolve, reject) => {
                promises.forEach((promise) => {
                    promise.then(
                        (res) => {
                            resolve(res);
                        },
                        (err) => {
                            reject(err);
                        },
                    );
                });
            });
        }
    };
});