class Promise {
constructor(executor) {
// 成功状态
// [[PromiseState]]: "fulfilled"
// [[PromiseResult]]: "ok"
this.PromiseState = 'pending'
this.PromiseResult = null
// 声明回调
this.callbacks = []
const _this = this
// console.log(_this)
// resolve
function resolve(data) {
// console.log(_this)
if (_this.PromiseState !== 'pending') return
_this.PromiseResult = data
_this.PromiseState = 'fulfilled'
setTimeout(() => {
_this.callbacks.forEach(item => {
item.resolved(data)
})
})
}
// reject
function reject(data) {
if (_this.PromiseState !== 'pending') return
// [[PromiseState]]: "rejected"
// [[PromiseResult]]: "ok"
_this.PromiseResult = data
_this.PromiseState = 'rejected'
// if(_this.callback.rejected){
// _this.callback.rejected(data)
// }
setTimeout(() => {
_this.callbacks.forEach(item => {
item.rejected(data)
})
})
}
// 同步调用执行器函数
try {
executor(resolve, reject)
} catch (e) {
reject(e)
}
}
then(resolved, rejected) {
}
then(resolved, rejected) {
if (typeof rejected !== 'function') {
rejected = reason => {
throw reason
}
}
if (typeof resolved !== 'function') {
resolved = value => value
}
return new Promise((resolve, reject) => {
const _this = this
function callback(type) {
try {
let result = type(_this.PromiseResult)
// resolved(this.PromiseResult)
// 不属于promise对象，返回fulfilled
if (result instanceof Promise) {
result.then(value => {
resolve(value)
}, reason => {
reject(reason)
})
} else {
resolve(result)
}
} catch (e) {
reject(e)
}
}
if (this.PromiseState == 'fulfilled') {
setTimeout(() => {
callback(resolved)
})
}
if (this.PromiseState == 'rejected') {
// callback(rejected)
setTimeout(() => {
callback(rejected)
})
}
if (this.PromiseState == 'pending') {
// 保存回调函数
this.callbacks.push({
resolved: function () {
// console.log('succuss')
setTimeout(() => {
callback(resolved)
})
},
rejected: function () {
setTimeout(() => {
callback(rejected)
});
}
})
}
})
}
catch(onRejected) {
return this.then(undefined, onRejected)
}
static resolve(value) {
return new Promise((resolve, reject) => {
if (value instanceof Promise) {
value.then(v => {
resolve(v)
}, r => {
reject(r)
})
} else {
resolve(value)
}
})
}
static reject(reason) {
return new Promise((resolve, reject) => {
reject(reason)
})
}
static all(promises) {
return new Promise((resolve, reject) => {
let count = 0
let arr = []
for (let i = 0; i < promises.length; i++) {
promises[i].then(v => {
count++
arr[i] = promises[i]
if (count == promises.length) {
resolve(arr)
}
}, reject => {
reject(reject)
})
}
})
}
static race(promises) {
return new Promise((resolve, reject) => {
for (let i = 0; i < promises.length; i++) {
promises[i].then(v => {
resolve(v)
}, j => {
reject(j)
})
}
})
}
}
742
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
