自定义 Promise

(function (window) {
    const PENDING = "pending";
    const RESOLVED = "resolved";
    const REJECTED = "rejected";

    function MyPromise(executor) {
        const self = this;
        self.status = PENDING;
        self.data = undefined;
        self.callback = [];      // item:{onResolved(),onRejected()}

        function resolve(value) {
            setTimeout(() => {
                if (self.status !== PENDING) { return; }
                self.status = RESOLVED;
                self.data = value;
                if (self.callback.length > 0) {
                    self.callback.forEach(item => {
                        item.onResolved(self.data);
                    })
                }
            })
        }

        function reject(reason) {
            setTimeout(() => {
                if (self.status !== PENDING) { return; }
                self.status = REJECTED;
                self.data = reason;
                if (self.callback.length > 0) {
                    self.callback.forEach(item => {
                        item.onRejected(self.data);
                    })
                }
            })
        }

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

    MyPromise.prototype.then = function (onResolved, onRejected) {
        const self = this;

        onResolved = typeof onResolved === "function" ? onResolved : value => value;
        onRejected = typeof onRejected === "function" ? onRejected : reason => { throw reason };


        return new MyPromise((resolve, reject) => {

            function handle(callback) {
                try {
                    const result = callback(self.data);
                    if (result instanceof MyPromise) {
                        result.then(resolve, reject);
                    } else {
                        resolve(result);
                    }
                } catch (error) {
                    reject(error);
                }
            }

            if (self.status === PENDING) {
                self.callback.push({
                    onResolved() {
                        handle(onResolved);
                    },
                    onRejected() {
                        handle(onRejected);
                    }
                })
            } else if (self.status === RESOLVED) {
                setTimeout(() => {
                    handle(onResolved);
                })
            } else {
                setTimeout(() => {
                    handle(onRejected);
                })
            }
        })
    }
    MyPromise.prototype.catch = function (onRejected) {
        this.then(undefined, onRejected);
    }

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

    MyPromise.all = function (promises) {
        const resultValue = new Array(promises.length);
        let resultCount = 0;

        return new MyPromise((resolve, reject) => {
            promises.forEach((p, index) => {
                MyPromise.resolve(p).then(
                    value => {
                        resultCount += 1;
                        resultValue[index] = value;
                        if (resultCount === promises.length) {
                            resolve(resultValue);
                        }
                    },
                    reason => {
                        reject(reason)
                    }
                );
            })
        })
    }

    MyPromise.race = function (promises) {
        return new MyPromise((resolve, reject) => {
            promises.forEach(p => {
                MyPromise.resolve(p).then(resolve, reject);
            })
        })
    }

    MyPromise.delayResolve = function (value, time = 0) {
        return new MyPromise((resolve, reject) => {
            setTimeout(() => {
                if (value instanceof MyPromise) {
                    value.then(resolve, reject);
                } else {
                    resolve(value);
                }
            }, time)
        })
    }

    MyPromise.delayReject = function (reason, time = 0) {
        return new MyPromise((resolve, reject) => {
            setTimeout(() => {
                reject(reason);
            }, time)
        })
    }

    window.MyPromise = MyPromise;
})(window)

测试：

<script src="./MyPromise.js"></script>
<script>
    const p = new MyPromise((resolve, reject) => {
        // resolve(1);
        reject(2);
        console.log("同步代码");
    });

    const p1 = MyPromise.delayResolve("ok");
    const p2 = MyPromise.delayReject("fuck", 200);
    const p3 = MyPromise.resolve(MyPromise.delayReject("err"));
    const n = 1;

    MyPromise.race([p2, p3, p1])
        .then(
        (value) => console.log("onResolved", value),
        (reason) => {
            console.log("onRejected", reason);
            throw 404;
        }
    )
        .then((value) => console.log("onResolved", value))
        .catch((reason) => console.log("onRejected", reason));
</script>