手写promise 及then resolve reject all race 方法

function Promise (excutor) {
this.promiseState = 'pending'
this.promiseResult = null
let self = this
this.callbacks = []
function resolve (data) {
if(self.promiseState !== 'pending') return
self.promiseState = 'fulfilled'
self.promiseResult = data
setTimeout(() => {
self.callbacks.forEach(item => {
item.onresolved(data)
})
})
}
function reject (data) {
if(self.promiseState !== 'pending') return
self.promiseState = 'rejected'
self.promiseResult = data
setTimeout(() => {
self.callbacks.forEach(item => {
item.onrejected(data)
})
})
}
// 改变状态可以 throew reject resolve 三种方法
try {
excutor(resolve, reject)
} catch (error) {
reject(error)
}

}

Promise.prototype.then = function (onresolved, onrejected) {
let self = this
if (typeof onresolved !== 'function') {
onresolved = res => res
}
if (typeof onrejected !== 'function') {
onrejected = err => {
throw err
}
}
return new Promise((resolve, reject) => {
// 注意函数中this为window
function callback (type) {
try {
let result = type(self.promiseResult)
if (result instanceof Promise) {
result.then(res => {
resolve(res)
}, err => {
reject(err)
})
} else {
resolve(result)
}
} catch (error) {
reject(error)
}

    }
    if (this.promiseState === 'fulfilled') {
        // onresolved(this.promiseResult)
        setTimeout(() => {
            callback(onresolved)
        })
    }
    if (this.promiseState === 'rejected') {
        // onrejected(this.promiseResult)
        setTimeout(() => {
            callback(onrejected)
        })
    }
    if (this.promiseState === 'pending') {
        this.callbacks.push({
            onresolved: function () {
                // onresolved(this.promiseResult)
                callback(onresolved)
            },
            onrejected: function () {
                // onrejected(this.promiseResult)
                callback(onrejected)
            } 
        })
    }
})

}
Promise.prototype.catch = function (onrejected) {
return this.then(undefined, onrejected)
}

Promise.resolve = function (val) {
return new Promise((resolve, reject) => {
if (val instanceof Promise) {
val.then(res => {
resolve(res)
}, err => {
reject(err)
})
} else {
resolve(val)
}
})
}

Promise.reject = function (val) {
return new Promise((resolve, reject) => {
reject(val)
})
}

Promise.all = function (arr) {
return new Promise((resolve, reject) => {
if (!Array.isArray(arr)) {
throw("不是数组")
}
let result = []
let count = 0
for(let i = 0; i < arr.length; i++) {
arr[i].then(res => {
result[i] = res
count++
if (count === arr.length) {
resolve(result)
}
}, err => {
reject()
})
}
})
}

Promise.race = function (promises) {
return new Promise((resolve, reject) => {
if (!Array.isArray(promises)) {
throw("不是数组")
}
for(let i = 0; i<promises.length; i++) {
promises[i].then(res => {
resolve(res)
}, err => {
reject(err)
})
}
})
}