class MyPromise {
constructor (executor) {
this.status = 'pending'
this.successVal = null
this.failVal = null
this.resolvedCallback = []
this.rejectedCallback = []
const resolved = (value) => {
console.log("resolved")
if(this.status !== 'pending') return
setTimeout(() => {
this.successVal = value
this.status = 'fulfilled'
this.resolvedCallback.forEach(fn => fn(this.successVal))
}, 100)
}
const rejected = (error) => {
if(this.status !== 'pending') return
setTimeout(() => {
this.failVal = error
this.status = 'rejected'
this.rejectedCallback.forEach(fn => fn(this.failVal))
}, 0)
}
try {
executor(resolved, rejected)
} catch (e) {
rejected(e)
}
}
then(onResolved, onRejected) {
console.log(this.status)
onResolved = typeof onResolved === 'function' ? onResolved : value => value
onRejected = typeof onRejected === 'function' ? onRejected : error => {throw error}
let resPromise
if(this.status === 'pending') {
resPromise = new MyPromise((res, rej) => {
this.resolvedCallback.push((value) => {
try {
let data = onResolved(value)
res(data)
} catch (e) {
rej(e)
}
})
this.rejectedCallback.push((error) => {
let data = onRejected(error)
rej(data)
})
})
} else if(this.status === 'fulfilled') {
resPromise = new MyPromise((res, rej) => {
setTimeout(() => {
try {
let data = onResolved(this.successVal)
res(data)
} catch (e) {
rej(e)
}
}, 0)
})
} else if (this.status === 'rejected') {
resPromise = new MyPromise((res, rej) => {
setTimeout(() => {
try {
let data = onRejected(this.failVal)
res(data)
} catch (e) {
rej(e)
}
})
})
}
return resPromise
}
catch (onRejected) {
return this.then(null, onRejected)
}
resolvePromise(resPromise, data, res, rej) {
if(resPromise === data) return rej(new TypeError("循环引用"))
if(!(resPromise instanceof MyPromise)) return res(data)
try {
const resloveFunction = (newData) => {
this.resolvePromise(resPromise, newData, res, rej)
}
const rejectFunction = (error) => {
rej(error)
}
data.then(resloveFunction, rejectFunction)
} catch (error) {
rej(error)
}
}
static resolve(val) {
if(val instanceof MyPromise) return val
return new MyPromise((res, rej) => {
if(val && val.then && typeof val.then === 'function') {
val.then(res, rej)
} else {
res(val)
}
})
}
static reject(error) {
return new MyPromise((res, rej) => {
rej(error)
})
}
static all(promiseArr) {
return new MyPromise((res, rej) => {
if(!Array.isArray(promiseArr)) return rej(new TypeError("传入类型必须为数组"))
let resArr = new Array(promiseArr.length)
let count = 0
for(let i = 0; i < promiseArr.length; i++) {
MyPromise.resolve(promiseArr[i]).then((item) => {
resArr[i] = item
count++
if(count === promiseArr.length) return res(resArr)
}).catch(err => rej(err))
}
})
}
static race(promiseArr) {
return MyPromise((res, rej) => {
if(!Array.isArray(promiseArr)) return rej(new TypeError("promiseArr must be an array"))
for(let i = 0; i < promiseArr.length; i++) {
MyPromise.resolve(promiseArr[i]).then((data) => {
res(data)
return
}).catch(err => {
rej(err)
return
})
}
})
}
finally(callback) {
this.then(value => {
return MyPromise.resolve(callback()).then(() => {
return value
})
}, error => {
return MyPromise.resolve(callback()).then(() => {
throw error
})
})
}
}
class MyPromise {
constructor(executor) {
this.status = 'pending'
this.successVal = null
this.failVal = null
this.resolvedCallback = []
this.rejectedCallback = []
const _resolve = (value) => {
if(this.status !== 'pending') return
setTimeout(() => {
this.status = 'fulfilled'
this.successVal = value
this.resolvedCallback.forEach(fn => fn(this.successVal))
}, 0)
}
const _reject = (error) => {
if(this.status !== 'pending') return
setTimeout(() => {
this.status = 'rejected'
this.failval = error
this.rejectedCallback.forEach(fn => fn(this.failval))
}, 0)
}
try {
executor(_resolve, _reject)
} catch (e) {
_reject(e)
}
}
then(onresloved, onrejected) {
onresloved = typeof onresloved === 'function' ? onresloved : value => value
onrejected = typeof onrejected === 'function' ? onrejected : error => {throw error}
let resPromise
switch(this.status) {
case 'pending':
resPromise = new MyPromise((res, rej) => {
this.resolvedCallback.push((value) => {
try {
let data = onresloved(value)
this.resolvePromise(resPromise, data, res, rej)
} catch (e) {
rej(e)
}
})
this.rejectedCallback.push((error) => {
try {
let data = onrejected(error)
res(data)
} catch (e) {
rej(e)
}
})
})
break
case 'fulfilled':
resPromise = new Promise((res, rej) => {
setTimeout(() => {
try {
let data = onresloved(this.successVal)
res(data)
} catch (e) {
rej(e)
}
}, 0)
})
break
case 'rejected':
resPromise = new Promise((res, rej) => {
setTimeout(() => {
try {
let data = onrejected(this.failVal)
rej(data)
} catch (e) {
rej(e)
}
}, 0)
})
}
return resPromise
}
resolvePromise(resPromise, data, resFunction, rejFunction) {
if(!(data instanceof MyPromise)) {
return resFunction(data)
}
if(resPromise === data) return rejFunction(new TypeError("循环引用错误"))
data.then((value => {
this.resolvePromise(resPromise, value, resFunction, rejFunction)
}), (error) => {
rejFunction(error)
})
}
catch (onrejected) {
return this.then(null, onrejected)
}
finally(callback) {
this.then((value) => {
return MyPromise.resolve(callback()).then(() => {
return value
})
}, err => {
return MyPromise.reject(callback()).then(() => {
return err
})
})
}
static resolve(value) {
if(value instanceof MyPromise) return data
return new MyPromise((res, rej) => {
if(value && value.then && typeof value.then === "function") {
value.then(res, rej)
} else {
res(value)
}
})
}
static reject(value) {
return new MyPromise((res, rej) => {
rej(value)
})
}
static all (promiseArr) {
if(!Array.isArray(promiseArr)) return _reject(new TypeError("param error"))
let result = []
return new MyPromise((res, rej) => {
for(let i = 0; i < promiseArr.length; i++) {
console.log(result)
MyPromise.resolve(promiseArr[i]).then((value) => {
result[i] = value
console.log(result)
if(i === promiseArr.length-1) {
console.log(result)
res(result)
}
}).catch(e => {
rej(e)
})
}
})
}
static race(promiseArr) {
if(!Array.isArray(promiseArr)) return _reject(new TypeError("param error"))
return new MyPromise((res, rej) => {
for(let i = 0; i < promiseArr.length; i++) {
MyPromise.resolve(promiseArr[i]).then((value) => {
return res(value)
}).catch((e) => {
rej(e)
return
})
}
})
}
}