SOURCE

class MyPromise {
    constructor(executor) {
        this.status = 'pending'; // 初始化状态为 pending
        this.value = null; // 初始化 value 为 null

        const resolve = (value) => {
            if (this.status === 'pending') { // 如果状态为 pending，才能转换为 fulfilled 状态
                this.status = 'fulfilled'; // 将状态改为 fulfilled
                this.value = value; // 将 value 设为传入的 value
            }
        };

        const reject = (reason) => {
            if (this.status === 'pending') { // 如果状态为 pending，才能转换为 rejected 状态
                this.status = 'rejected'; // 将状态改为 rejected
                this.value = value; // 将 reason 设为传入的 value
            }
        };

        try {
            executor(resolve, reject); // 执行 executor 函数，并传入 resolve 和 reject 函数
        } catch (error) {
            reject(error); // 如果在 executor 函数中抛出了异常，将异常传给 reject 函数处理
        }
    }

    then(onFulfilled, onRejected) {
        // 接收两个回调 onFulfilled, onRejected
        let thenPromise = new MyPromise((resolve, reject) => {
            const resolvePromise = cb => {
                try {
                    const x = cb(this.value)
                    if (x === thenPromise) {
                        // 不能返回自身哦
                        throw new Error('不能返回自身哦')
                    }
                    if (x instanceof MyPromise) {
                        // 如果返回值是Promise
                        // 如果返回值是promise对象，返回值为成功，新promise就是成功
                        // 如果返回值是promise对象，返回值为失败，新promise就是失败
                        // 谁知道返回的promise是失败成功？只有then知道
                        x.then(resolve, reject)
                    } else {
                        // 非Promise就直接成功
                        resolve(x)
                    }
                } catch (err) {
                    // 处理报错
                    reject(err)
                    throw new Error(err)
                }
            };

            if (this.status === 'fulfilled') {
                // 如果当前为成功状态，执行第一个回调
                resolvePromise(onFulfilled)
            } else if (this.status === 'rejected') {
                // 如果当前为失败状态，执行第二个回调
                resolvePromise(onRejected)
            };
        })

        // 返回这个包装的Promise
        return thenPromise
    }
}

// 使用示例
const promise = new MyPromise((resolve, reject) => {
    setTimeout(() => {
        resolve('Hello, world!');
    }, 1000);
});

promise.then(value => {
    console.log(value); // 输出 "Hello, world!"
});