SOURCE

class MyPromise {
    constructor(executor) {
        this.initValue();
        this.initBind();
        try {
            executor(this.resolve, this.reject);
        } catch (e) {
            this.reject(e);
        }

    }

    initBind() {
        this.resolve = this.resolve.bind(this);
        this.reject = this.reject.bind(this);
    }

    initValue() {
        this.promiseStatus = 'pending';
        this.promiseResult = null;
        this.onFulfilledCallbacks = [];
        this.onRejectedCallbacks = [];
    }

    resolve(value) {
        if (this.promiseStatus !== 'pending') return;
        this.promiseStatus = 'fulfilled';
        this.promiseResult = value;
        while (this.onFulfilledCallbacks.length) {
            this.onFulfilledCallbacks.shift()(this.promiseResult);
        }
    }

    reject(reason) {
        if (this.promiseStatus !== 'pending') return;
        this.promiseStatus = 'rejected';
        this.promiseResult = reason;
        while (this.onRejectedCallbacks.length) {
            this.onRejectedCallbacks.shift()(this.promiseResult);
        }
    }

    then(onFulfilled, onRejected) {
        // console.log('onFulfilled', onFulfilled)
        // console.log('onRejected', onRejected)
        // console.log('this.promiseStatus', this.promiseStatus)

        // 参数校验，确保一定是函数
        onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : val => val
        onRejected = typeof onRejected === 'function' ? onRejected : reason => { throw reason }

        const thenPromise = new MyPromise((resolve, reject) => {
            const resolvePromise = cb => {
                setTimeout(() => {
                    try {
                        const x = cb(this.promiseResult);
                        if (x === thenPromise) {
                            throw new Error('不能返回自身');
                        }
                        if (x instanceof MyPromise) {
                            x.then(resolve, reject);
                        } else {
                            resolve(x);
                        }
                    } catch (e) {
                        reject(e);
                        throw new Error(e);
                    }
                })
            }

            if (this.promiseStatus === 'fulfilled') {
                resolvePromise(onFulfilled);
            } else if (this.promiseStatus === 'rejected') {
                resolvePromise(onRejected);
            } else if (this.promiseStatus === 'pending') {
                this.onFulfilledCallbacks.push(() => resolvePromise(onFulfilled));
                this.onRejectedCallbacks.push(() => resolvePromise(onRejected));
            }
        })

        return thenPromise;
    }

    catch(onRejected) {
        this.then(undefined, onRejected);
    }

    all(promises) {
        const result = [];
        const count = 0;
        return new MyPromise((resolve, reject) => {
            const addData = (index, value) => {
                result[index] = value;
                count++;
                if (count === promises.length) resolve(result);
            }
            promises.forEach((item, index) => {
                if (item instanceof MyPromise) {
                    item.then(res => {
                        addData(index, res);
                    }, err => reject(err));
                } else {
                    addData(index, item);
                }
            })
        })
    }

    race(promises) {
        return new MyPromise((resolve, reject) => {
            promises.forEach((item) => {
                if (item instanceof MyPromise) {
                    item.then(res => {
                        resolve(res);
                    }, err => {
                        reject(err);
                    })
                } else {
                    resolve(item);
                }
            })
        })
    }
}

// const test1 = new MyPromise((resolve, reject) => {
//     resolve(100);
//     reject('失败1');
// }).then(res => console.log('res',res), err => console.log('err', err))
// console.log('test1', test1)

// const test2 = new MyPromise((resolve, reject) => {
//     reject('失败');
//     resolve('成功1');
// }).then(res => console.log('res',res), err => console.log('err', err))
// console.log('test2', test2)

// const test3 = new MyPromise((resolve, reject) => {
//     throw ('错误')
// })
// console.log('test3', test3)

// const test2 = new MyPromise((resolve, reject) => {
//     setTimeout(() => {
//         resolve('成功') // 1秒后输出 成功
//         // resolve('成功') // 1秒后输出 失败
//     }, 1000)
// }).then(res => console.log(res), err => console.log(err))

// const p2 = new MyPromise((resolve, reject) => {
//     setTimeout(() => {
//         reject('失败')
//     }, 1000)
// }).then(res => console.log(res), err => {
//     console.log('err222', err)
// })
// console.log('p2', p2)

// const test4 = new MyPromise((resolve, reject) => {
//     resolve(100);
// }).then(res => 2 * res, err => 3 * err)
//     .then(res => console.log('res', res), err => console.log('err1', err))

// const test5 = new MyPromise((resolve, reject) => {
//     // resolve(100) // 输出 状态：失败 值：200
//     reject(100) // 输出 状态：成功 值：300
//     // 这里可没搞反哦。真的搞懂了，就知道了为啥这里是反的
// }).then(res => new MyPromise((resolve, reject) => reject(2 * res)), err => new Promise((resolve, reject) => resolve(3 * err)))
//     .then(res => console.log('成功', res), err => console.log('失败', err))

// const test6 = new MyPromise((resolve, reject) => {
//     resolve(1)
// }).then(res => console.log(res), err => console.log(err))

// console.log(2)

// // 测试用例2：间接循环引用
// const test2 = new MyPromise((resolve) => {
//     resolve(200);
// });

// let p2;
// p2 = test2.then(() => {
//     return p2; // 间接引用自身
// });

const test7 = new MyPromise((resolve, reject) => {
    throw error;
}).catch(e => {
    console.log('e', e);
})