手写promise

function MyPromise(executor) {
    var self = this;
    self.status = 'pending';
    self.data = undefined;
    self.onResolveCallback = [];
    self.onRejectCallback = [];

    function resolve(value) {
        if (self.status === 'pending') {
            self.status = 'resolved';
            self.data = value;
            for (var i = 0; i < self.onResolveCallback.length; i++) {
                self.onResolveCallback[i](value)
            }
        }
    }

    function reject(reason) {
        if (self.status === 'pending') {
            self.status = 'rejected';
            self.data = reason;
            for (var i = 0; i < self.onRejectCallback.length; i++) {
                self.onRejectCallback[i](reason)
            }
        }
    }
    try {
        executor(resolve, reject)
    } catch (err) {
        reject(err)
    }
}
MyPromise.prototype.then = function (onResolved, onRejected) {
    var self = this;
    var promise2;
    onResolved = typeof onResolved === 'function' ? onResolved : function (val) {
        return val
    };
    onRejected = typeof onRejected === 'function' ? onRejected : function (reason) {
        return reason
    };
    if (self.status === 'resolved') {
        return promise2 = new MyPromise(function (resolve, rejected) {
            try {
                var x = onResolved(self.data);
                if (x instanceof Promise) {
                    x.then(resolve, reject)
                }
                resolve(x);
            } catch (e) {
                reject(e)
            }
        })
    }
    // 此处与前一个if块的逻辑几乎相同，区别在于所调用的是onRejected函数，就不再做过多解释
    if (self.status === 'rejected') {
        return promise2 = new MyPromise(function (resolve, reject) {
            try {
                var x = onRejected(self.data)
                if (x instanceof Promise) {
                    x.then(resolve, reject)
                }
            } catch (e) {
                reject(e)
            }
        })
    }
    if (self.status === 'pending') {
        return promise2 = new MyPromise(function (resolve, reject) {
            self.onResolveCallback.push(function (value) {
                try {
                    var x = onResolved(self.data);
                    if (x instanceof Promise) {
                        x.then(resolve, reject);
                    }
                } catch (e) {
                    reject(e)
                }
            })
            self.onRejectCallback.push(function (reason) {
                try {
                    var x = onRejected(self.data);
                    if (x instanceof Promise) {
                        x.then(resolve, reject)
                    }
                } catch (e) {
                    reject(e)
                }
            })
        })
    }
}
MyPromise.prototype.catch = function (onRejected) {
    return this.then(null, onRejected)
}
var demo = new MyPromise(function (resolve, reject) {
    setTimeout(function () {
        resolve(42)
    }, 2000)
})
demo.then(res => {
    console.log(res)
})