function Promise(executor) {
this.PromiseState = "pending"
this.PromiseResult = null
this.callbacks = []
const self = this
// resolve函数
function resolve(data) {
// 状态值只能修改一次
if (self.PromiseState !== "pending") return
// 修改primise状态
self.PromiseState = "fulfilled"
//设置对象结果值
self.PromiseResult = data
setTimeout(() => {
self.callbacks.forEach(item => {
item.onResolved(data)
})
})
}
// reject函数
function reject(data) {
if (self.PromiseState !== "pending") return
// 修改primise状态
self.PromiseState = "rejected"
//设置对象结果值
self.PromiseResult = data
setTimeout(() => {
self.callbacks.forEach(item => {
item.onRejected(data)
})
})
}
// 同步调用执行器函数
try {
executor(resolve, reject)
} catch (error) {
reject(error)
}
}
Promise.prototype.then = function (onResolved, onRejected) {
const self = this
if (typeof onRejected !== "function") {
onRejected = reason => {
throw reason
}
}
if (typeof onResolved !== "function") {
onResolved = value => value
}
return new Promise((resolve, reject) => {
function callback(type) {
try {
let result = type(self.PromiseResult)
if (result instanceof Promise) {
result.then(v => {
resolve(v)
}, r => {
reject(r)
})
} else {
resolve(result)
}
} catch (error) {
reject(error)
}
}
if (this.PromiseState === "fulfilled") {
setTimeout(() => {
callback(onResolved)
})
//callback(onResolved)
}
if (this.PromiseState === "rejected") {
setTimeout(() => {
callback(onRejected)
})
}
if (this.PromiseState === "pending") {
//保存回调函数
this.callbacks.push({
onResolved: function () {
callback(onResolved)
},
onRejected: function () {
callback(onRejected)
},
})
}
})
}
Promise.prototype.catch = function (onRejected) {
return this.then(undefined, onRejected)
}
Promise.resolve = function (value) {
return new Promise((resolve, reject) => {
if (value instanceof Promise) {
value.then(v => {
resolve(v)
}, r => {
reject(r)
})
} else {
resolve(value)
}
})
}
Promise.reject = function (reason) {
return new Promise((_, reject) => {
reject(reason)
})
}
Promise.all = function (promises) {
return new Promise((resolve, reject) => {
let conut = 0
let arr = []
for (let i = 0; i < promises.length; i++) {
promises[i].then(v => {
conut++
arr[i] = v;
if (conut === promises.length) {
resolve(arr)
}
}, r => {
reject(r)
})
}
})
}
Promise.race = function (promises) {
return new Promise((resolve, reject) => {
for (let i = 0; i < promises.length; i++) {
promises[i].then(v => {
resolve(v)
}, r => {
reject(r)
})
}
})
}
手写Promise实现
最新推荐文章于 2022-07-24 13:55:17 发布