1. Promise.all()方法：
返回全部成功结果的数组值，如果有报错，立即返回reject，结束。
// all 方法：全部成功返回一个数组，失败就返回失败的值
myPromise.all = (values) => {//传入的是一个数组 [p1,p2]
return new myPromise((resolve, reject) => {
let results = [];
let i = 0;
let processData = (value, index) => {
results[index] = value;
i++;
if (i === values.length) {
resolve(results)
}
}
for (let i = 0; i < values.length; i++) {
//获取当前的函数
let current = values[i];
//判断是函数还是变量
if (typeof current === 'function' || (typeof current === 'object' && typeof current !== null)) {
if (typeof current.then === 'function') {
current.then(y => {
processData(y, i)
}, err => {
reject(err); //只要有一个传入的promise没有执行成功就走 reject
return;
})
} else {
//常量
processData(values[i], i)
}
}
}
})
}
2. Promise.race()方法：
返回第一个结果，不管成功或失败。
// race 方法：先快执行谁，然后返回
myPromise.race = (values) => {//传入的是一个数组[p1,p2]
return new myPromise((resolve, reject) => {
for (let i = 0; i < values.length; i++) {
let current = values[i];
if (typeof current === 'function' || (typeof current === 'object' && typeof current !== null)) {
current.then(y => {
resolve(y)
return
}, err => {
reject(err)
return
})
} else {
resolve(current)
}
}
})
}
3.源码
class myPromise {
constructor(executor) {
this.state = 'pending'; //状态值
this.value = undefined; //成功的返回值
this.reason = undefined; //失败的返回值
this.onResolveCallbacks = []; //成功的回调函数
this.onRejectCallbacks = []; //失败的回调函数
//成功
let resolve = (value) => {
if (this.state === 'pending') {
this.state = 'fullFilled'
this.value = value
this.onResolveCallbacks.forEach(fn => fn())
}
}
//失败
let reject = (reason) => {
if (this.state === 'pending') {
this.state = 'rejected'
this.reason = reason
this.onRejectCallbacks.forEach(fn => fn())
}
}
try {
//执行函数
executor(resolve, reject)
} catch (err) {
//失败则直接执行reject函数
reject(err)
}
}
then(onFullfilled, onRejected) {
// then 返回一个promise ，这样就是一个递归
let promise2 = new myPromise((resolve, reject) => {
let x;
if (this.state === 'fullFilled') {
//同步，状态为fullfilled,执行 onFullfilled,传入成功的值
setTimeout(() => {
try {
x = onFullfilled(this.value)
resolvePromise(promise2, x, resolve, reject)
} catch (error) {
//中间任何一个环节报错都走reject
reject(error)
}
}, 0)//同步无法使用promise2，所以借用setTimeout异步的方式。
}
if (this.state === 'rejected') {
//异步，rejected,执行 onRejected,传入失败的值
setTimeout(() => {
try {
x = onRejected(this.reason)
resolvePromise(promise2, x, resolve, reject)
} catch (error) {
//中间任何一个环节报错都走reject
reject(error)
}
}, 0)//同步无法使用promise2，所以借用setTimeout异步的方式。
}
//异步
if (this.state === 'pending') {
this.onResolveCallbacks.push(() => {
setTimeout(() => {
try {
x = onFullfilled(this.value)
resolvePromise(promise2, x, resolve, reject)
} catch (error) {
//中间任何一个环节报错都走reject
reject(error)
}
}, 0)//同步无法使用promise2，所以借用setTimeout异步的方式。
})
this.onRejectCallbacks.push(() => {
setTimeout(() => {
try {
x = onRejected(this.reason)
resolvePromise(promise2, x, resolve, reject)
} catch (error) {
//中间任何一个环节报错都走reject
reject(error)
}
}, 0)//同步无法使用promise2，所以借用setTimeout异步的方式。
})
}
})
return promise2;//返回promise
}
finally(callback) {
return this.then(callback, callback)
}
catch(rejectFuc) {
return this.then(null, rejectFuc);
}
}
// 这个方法的主要左右是用来判断x的值，如果x的值是一个普通的值，就直接返回x的值，如果x的值是一个promise，就要返回x.then()执行的结果，核心代码如下
const resolvePromise = (promise2, x, resolve, reject) => {
// x和promise2不能是同一个，如果是同一个就报错
if (promise2 === x) {
return reject(
new TypeError('Chaining cycle detected for promise #<promise>')
)
}
// 判断x是否是一个对象，判断函数是否是对象的方法有： typeof instanceof constructor toString
if (typeof x === 'object' && x != null || typeof x === 'function') {
let called;
try {
let then = x.then; //取 then可以报错，报错就走 reject();
if (typeof then === 'function') {
then.call(x, y => {
console.log('y', y);
if (called) return;
called = true;
resolve(y); //采用promise的成功结果，并且向下传递
resolvePromise(promise2, y, resolve, reject)
}, r => {
if (called) return;
called = true;
reject(r);//采用promise的成功结果，并且向下传递
})
} else {
resolve(x); //x不是一个函数，是一个对象
}
} catch (error) {
if (called) return;
called = true;
reject(error);//报错就走 reject();
}
} else {
// x是一个普通值
resolve(x)
}
}
myPromise.resolve = (value) => {
return new myPromise((resolve, reject) => {
resolve(value)
})
}
myPromise.reject = (value) => {
return new myPromise((resolve, reject) => {
reject(value)
})
}
// all 方法：全部成功返回一个数组，失败就返回失败的值
myPromise.all = (values) => {//传入的是一个数组 [p1,p2]
return new myPromise((resolve, reject) => {
let results = [];
let i = 0;
let processData = (value, index) => {
results[index] = value;
i++;
if (i === values.length) {
resolve(results)
}
}
for (let i = 0; i < values.length; i++) {
//获取当前的函数
let current = values[i];
//判断是函数还是变量
if (typeof current === 'function' || (typeof current === 'object' && typeof current !== null)) {
if (typeof current.then === 'function') {
current.then(y => {
processData(y, i)
}, err => {
reject(err); //只要有一个传入的promise没有执行成功就走 reject
return;
})
} else {
//常量
processData(values[i], i)
}
}
}
})
}
// race 方法：先快执行谁，然后返回
myPromise.race = (values) => {//传入的是一个数组[p1,p2]
return new myPromise((resolve, reject) => {
for (let i = 0; i < values.length; i++) {
let current = values[i];
if (typeof current === 'function' || (typeof current === 'object' && typeof current !== null)) {
current.then(y => {
resolve(y)
return
}, err => {
reject(err)
return
})
} else {
resolve(current)
}
}
})
}
let p = new myPromise((resolve, reject) => {
// resolve('成功') //走了成功就不会走失败
// throw new Error('失败了');
// reject('failed') // 走了失败就不会走成功
setTimeout(() => {
resolve('success')
}, 0)
})
p.then(res => {
console.log(res);
}, err => {
console.log(err);
})
console.log(p);
