class Promise {
//构造函数
constructor(executor) {
//添加属性
this.PromiseState = 'pending';
this.PromiseResult = null;
//声明属性
this.callbacks = [];
//保存实例对象this的值
const _this = this
//resolve函数
function resolve(data) {
if (_this.PromiseState !== 'pending') return
//修改对象状态(promiseState)
_this.PromiseState = 'fulfilled';
//设置对象结果值(promiseResult)
_this.PromiseResult = data
setTimeout(() => {
_this.callbacks.forEach(item => {
//失败的回调
item.onResolved(data)
})
})
}
//reject函数
function reject(data) {
if (_this.PromiseState !== 'pending') return
//修改对象状态(promiseState)
_this.PromiseState = 'rejected';
//设置对象结果值(promiseResult)
_this.PromiseResult = data
//执行和成功的回调
setTimeout(() => {
_this.callbacks.forEach(item => {
//失败的回调
item.onRejected(data)
})
})
}
//同步调用 执行器函数
try {
executor(resolve, reject);
} catch (e) {
//修改Promise对象状态
reject(e)
}
}
//then方法
then(onResolved, onRejected) {
const that = 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(that.PromiseResult);
if (result instanceof Promise) {
//如果是Promise类型的对象
result.then(v => {
resolve(v)
}, r => {
reject(r)
})
} else {
//设置对象为成功
resolve(result)
}
} catch (e) {
reject(e)
}
}
//调用回调函数 PromiseState
if (this.PromiseState == 'fulfilled') {
setTimeout(() => {
callback(onResolved)
})
}
if (this.PromiseState == 'rejected') {
setTimeout(() => {
callback(onRejected)
})
}
//判断pending状态
if (this.PromiseState == 'pending') {
//.....保存回调函数
this.callbacks.push({
onResolved: function () {
callback(onResolved)
},
onRejected: function () {
callback(onRejected)
}
})
}
})
}
//catch方法
catch(onRejected) {
return this.then(undefined, onRejected);
}
//添加resolve
static resolve(value) {
return new Promise((resolve, reject) => {
if (value instanceof Promise) {
try {
value.then(v => {
resolve(v)
}, r => {
reject(r)
})
} catch (e) {
}
} else {
resolve(value)
}
})
}
static reject(value) {
return new Promise((resolve, reject) => {
reject(value)
})
}
//添加all方法
static all(promises) {
//返回结果为promise对象
return new Promise((resolve, reject) => {
let count = 0;
let arr = [];
//便利
for (let i = 0; i < promises.length; i++) {
promises[i].then(v => {
//得知对象的状态是成功的
//每个promise对象都成功
count++;
//将当前promise成功的对象村到数组中
arr[i] = v;
//
if (count == promises.length) {
//修改状态
resolve(arr)
}
}, r => {
reject()
})
}
})
}
//添加race方法
static race(promises) {
return new Promise((resolve, reject) => {
for (let a = 0; a < promises.length; a++) {
promises[a].then(v => {
//修改状态
resolve(v)
}, r => {
reject(r)
})
}
})
}
}
手写Promise
最新推荐文章于 2023-06-27 15:28:28 发布