-
-
Notifications
You must be signed in to change notification settings - Fork 230
New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
1. 实现一个Promise.all #1
Comments
/**
* 得到一个新的Promise,该Promise的状态取决于proms的执行
* proms是一个迭代器,包含多个Promise
* 全部Promise成功,返回的Promise才成功,数据为所有Primsise成功的数据,并且顺序时按照传入的顺序排列
* 只要有一个Promise失败,则=返回的Pormise失败,原因是第一个Promise失败的原因
* @param {iterator} proms
*/
Promise.all=function (proms) {
return new MyPromise((resolve, reject) => {
try {
const results = []; //接受每个Promise成功后的结果
let count = 0; // Promse计数总数
let fulfilledCount = 0; // 已完成的数量
for (const p of proms) {
// resolve([1,2,3,4])
// 思考:如何保证数组是有序的?如何知道啥时候所有promise都完成?
let i = count; // 保存一下当前下标
count++;
/**
* 先包一下p,处理有直接写数字的情况
*/
MyPromise.resolve(p).then((data) => {
//异步,代码运行到这里,循环就已经结束了,因为在微队列
fulfilledCount++;
// console.log(i);
results[i] = data;
// results.push(data);不能用push
console.log(fulfilledCount);
if (fulfilledCount === count) {
// 当前是最后一个Promise完成了
console.log("全部完成");
resolve(results);
}
}, reject);
}
console.log(count, fulfilledCount);
/**
* 特殊情况1:传递空数组
*/
if (count === 0) {
resolve(results);
}
} catch (error) {
reject(error);
console.error(error);
}
/**
* 特殊情况2:执行中报错:try,catch
*/
});
}
/*******test all *******/
/**
* 不仅可以传数组,还可以传递迭代器。不是所有迭代器都支持for循环,所以。。。
*/
Promise.all([
MyPromise.reject(1),
MyPromise.resolve(2),
MyPromise.resolve(3),
4,
]).then(
(data) => {
// data:[1,2,3,4]
// 传递[pro1,pro2,pro3,4]的话:内部默认处理Promise.resolve(4)
console.log("成功", data);
},
(reason) => {
// reason:reason2
console.log("失败", reason);
}
); |
Promise._all = function (promises) {
// 该方法返回一个promise对象
return new Promise((resolve, reject) => {
// 该方法的参数需为一个可迭代对象
if (promises == null || typeof promises[Symbol.iterator] !== "function") {
throw new TypeError(`${promises} is not a iterable`);
}
promises = [...promises];
// 可迭代对象为空则返回已resolve的promise
if (promises.length === 0) {
resolve([]);
}
let count = 0;
const values = [];
promises.forEach((promise, index) => {
// 保证可迭代对象的元素为promise,使用Promise.resolve()处理
Promise.resolve(promise)
.then((res) => {
values[index] = res;
if (++count === promises.length) resolve(values);
})
.catch(reject);
});
});
}; |
Promise._all = (iterObj) => {
// 1. iterObj 必须是一个可迭代对象, 否则, 无法正常进行则抛出错误
if(!(typeof iterObj === "object" && iterObj !== null && typeof iterObj[Symbol.iterator] === "function")){
throw new TypeError(`${iterObj} is not iterable`);
}
iterObj = [...iterObj];
/*
* 2. 函数返回值为 `<Promise>` 对象, 当参数 `iterObj` 内所有的 `Promise` 成功,
* 该 `<Promise>` 对象成功, 成功数据为所有成功的 `Promise` 结果数组,
* 有一个不成功, 则该 `<Promise>` 不成功, 失败数据为失败原因字符串
*/
return new Promise((resolve, reject) => {
const len = iterObj.length;
let count = 0;
if(len === 0) return resolve([]);
const res = new Array(len);
iterObj.forEach(async (item, index) => {
const newItem = Promise.resolve(item);
try{
const result = await newItem;
res[index] = result;
if(++count === len){
resolve(res)
}
}catch(err){
reject(err);
}
})
})
}
// 验证:
function test(){
try{
Promise._all(null).then(res=>console.log(res), rej=>console.log(rej));
// throw err: null is not iterable
}catch(e){
console.log(e)
}
try{
Promise._all({}).then(res=>console.log(res), rej=>console.log(rej));
// throw err: [object object] is not iterable
}catch(e){
console.log(e)
}
Promise._all([]).then(res=>console.log(res), rej=>console.log(rej));
// []
Promise._all(new Set()).then(res=>console.log(res), rej=>console.log(rej));
// []
Promise._all(new Map()).then(res=>console.log(res), rej=>console.log(rej));
// []
Promise._all([
Promise.resolve(1),
Promise.resolve(2),
Promise.resolve(3),
4,
]).then(res=>console.log(res), rej=>console.log(rej))
// [1, 2, 3, 4]
Promise._all([
Promise.reject(1),
Promise.resolve(2),
Promise.resolve(3),
4,
]).then(res=>console.log(res), rej=>console.log(rej))
// 1
}
test(); |
Promise.myAll = (promises) => {
return new Promise((resolve, reject) => {
let count = 0
let result = []
const len = promises.length
if (len === 0) {
return resolve([])
}
promises.forEach((p, i) => {
Promise.resolve(p).then((res) => {
count += 1
result[i]=res
if(count === len) {
resolve(result)
}
}).catch(reject)
})
})
} |
Promise.myAll = (promises) => {
return new Promise((resolve, reject) => {
let idx = 0;
const ans = [];
promises.forEach((item, index) => {
Promise.resolve(item).then(
(res) => {
ans[index] = res;
idx++;
if (idx === promises.length) {
resolve(ans);
}
},
(err) => reject(err)
);
});
});
}; |
Promise._all = function (promiseList) {
return new Promise((resolve, reject) => {
// 如果传入的参数 不是数组
if (!Array.isArray(promiseList)) {
return reject(new Error("传入的参数不是数组!"));
}
const res = [];
let counter = 0; // 设置一个计数器
for (let i = 0; i < promiseList.length; i++) {
Promise.resolve(promiseList[i])
.then((val) => {
counter++;
res[i] = val; // 返回值
if (counter == promiseList.length) {
resolve(res);
}
})
.catch((e) => reject(e));
}
});
}; |
|
|
Promise.myAll = function (iterObj) {
//1. 检查arr是否是可迭代的对象
if (
!(
typeof iterObj === "object" &&
iterObj !== null &&
typeof iterObj[Symbol.iterator] === "function"
)
) {
throw new Error(`${iterObj} is not iterable`);
}
iterObj = [...iterObj];
// 创造一个新的promise
return new Promise((resolve, reject) => {
const results = [];
let count = 0;
let finished = 0;
for (let p of iterObj) {
let index = count;
count++;
// 如果传入的p不是promise直接resolve
// 到这一步时所有的for loop 已经结束
Promise.resolve(p).then(
(res) => {
finished++;
results[index] = res;
if (finished === count) {
resolve(results);
}
},
(rej) => {
reject(rej);
}
);
}
});
};
p1 = Promise.resolve(1);
p2 = new Promise((res, rej) => {
setTimeout(() => {
res(2);
}, 1000);
});
p3 = new Promise((res, rej) => {
setTimeout(() => {
res(3);
});
});
const arr = [];
arr.push(p1);
arr.push(p2);
arr.push(p3);
Promise.myAll(arr).then((res) => {
console.log(res);
}); |
function myPromiseAll(promises) {
// 检查是否是迭代对象
if(typeof promises[Symbol.iterator] !== 'function') {
throw(`传入的参数不是一个可迭代对象`)
}
return new Promise((resolve, reject) => {
const results = [];
let count = 0;
promises.forEach((promise, index) => {
Promise.resolve(promise)
.then(result => {
results[index] = result;
count++;
if (count === promises.length) {
resolve(results);
}
})
.catch(error => {
reject(error);
});
});
});
} |
class MyPromise {
static all(promise) {
if (
!(
typeof promise === "object" &&
promise !== null &&
typeof promise[Symbol.iterator] === "function"
)
) {
throw new Error(`${promise} is not iterator`);
}
return new Promise((resolve, reject) => {
const length = promise.length;
if (length === 0) {
resolve([]);
}
const results = [];
let idx = 0;
promise.forEach((promise, index) => {
Promise.resolve(promise)
.then((res) => {
idx++;
// 返回值跟传入的promise一一对应
results[index] = res;
// 确保所有promise都执行完成
if (idx === length) {
resolve(results);
}
})
.catch((error) => {
reject(error);
});
});
});
}
}
function test() {
try {
MyPromise.all(1)
.then((res) => console.log(res))
.catch((err) => console.log("reject", err));
} catch (error) {
console.log("catch", error);
}
try {
MyPromise.all({})
.then((res) => console.log(res))
.catch((err) => console.log("reject", err));
} catch (error) {
console.log("catch", error);
}
try {
MyPromise.all([])
.then((res) => console.log("success", res))
.catch((err) => console.log("reject", err));
} catch (error) {
console.log("catch", error);
}
MyPromise.all([Promise.resolve(1), {}])
.then((res) => console.log("success", res))
.catch((err) => console.log("reject", err));
MyPromise.all([Promise.reject("12312321"), Promise.resolve(123)])
.then((res) => console.log("success", res))
.catch((err) => console.log("reject", err));
}
test(); |
Promise.myall = (promises) => {
//判断当前数据能否迭代
if (
!(
typeof promises === "object" &&
promises !== null &&
typeof promises[Symbol.iterator] === "function"
)
) {
throw new TypeError(`${promises} is not iterable`);
}
promises = [...promises];
return new Promise((resolve, reject) => {
const len = promises.length;
if (len === 0) return resolve([]);
const ans = [];
let cnt = 0;
promises.forEach(async (promise) => {
try {
const res = await promise;
ans.push(res);
//当所有promise对象都成功时返回成功的promise对象
if (++cnt === len) resolve(ans);
} catch (error) {
//当出现失败的promise对象时立刻返回错误的原因error
reject(error);
}
});
});
};
//test
try {
Promise.myall({}).then(
(res) => console.log(res),
(rej) => console.log(rej)
); //TypeError: [object Object] is not iterable
} catch (error) {
console.log(error);
}
Promise.myall([
Promise.resolve(1),
Promise.resolve(2),
Promise.resolve(3),
4,
]).then(
(res) => console.log(res), //[ 1, 2, 3, 4 ]
(rej) => console.log(rej)
);
Promise.myall([
Promise.resolve(1),
Promise.resolve(2),
Promise.reject(3),
4,
]).then(
(res) => console.log(res),
(rej) => console.log(rej) // 3
);
Promise.myall([
Promise.resolve(1),
Promise.resolve(2),
Promise.reject(3).catch((err) => console.log(err)), //3
4,
]).then(
(res) => console.log(res), //[ 1, 2, 4, undefined ]
(rej) => console.log(rej)
); |
/**
* 得到一个新的Promise,该Promise的状态取决于proms的执行
* proms是一个迭代器,包含多个Promise
* 全部Promise成功,返回的Promise才成功,数据为所有Primsise成功的数据,并且顺序时按照传入的顺序排列
* 只要有一个Promise失败,则=返回的Pormise失败,原因是第一个Promise失败的原因
* @param {iterator} proms
*/
function PromiseAll(proms) {
return new Promise((resolve, reject) => {
let fulfilledCount = 0;
const res = [];
proms.forEach((p, index) => {
p.then((val) => {
fulfilledCount++;
res[index] = val;
if (fulfilledCount == proms.length) resolve(res);
}, reject)
})
})
}
// const p1 = Promise.resolve('p1')
// const p2 = new Promise((resolve, reject) => {
// setTimeout(() => {
// resolve('p2 延时一秒')
// }, 1000)
// })
// const p3 = new Promise((resolve, reject) => {
// setTimeout(() => {
// resolve('p3 延时两秒')
// }, 2000)
// })
// const p4 = Promise.reject('p4 rejected')
// const p5 = new Promise((resolve, reject) => {
// setTimeout(() => {
// reject('p5 rejected 延时1.5秒')
// }, 1500)
// })
//成功
// const res1 = PromiseAll([p1, p2, p3])
// res1.then(val => console.log('res1', val),val => console.error(res1,val))
// 一个失败
// const res2 = PromiseAll([p1, p2, p4])
// res2.then(val => console.log('res2', val),val => console.error(res2,val))
//一个延时失败
// const res3 = PromiseAll([p1, p2, p5])
// res3.then(val => console.log('res3', val), val => console.error('res3', val))
//两个失败
// const res4 = PromiseAll([p1, p4, p5])
// res4.then(val => console.log('res4', val), val => console.error('res4', val)); |
Promise.all = function(promises) {
return new Promise((resolve, reject) => {
let result = [];
let len = promises.length;
if(len === 0) {
resolve(result);
return;
}
const handleData = (data, index) => {
result[index] = data;
// 最后一个 promise 执行完
if(index == len - 1) resolve(result);
}
for(let i = 0; i < len; i++) {
// 为什么不直接 promise[i].then, 因为promise[i]可能不是一个promise
Promise.resolve(promise[i]).then(data => {
handleData(data, i);
}).catch(err => {
reject(err);
})
}
})
} |
Promise.All = function(props) { |
|
Promise.All = function (ites) { |
Promise.all = function (list) {
const result = []
let count = 0
return new Promise((resolve, reject) => {
list.forEach((item, i) => {
Promise.resolve(item).then(res => {
result[i] = res
count++
}).catch(err => {
reject(err)
})
})
if (count === list.length) {
resolve(result)
}
})
} |
// promise.all会返回一个新的promise,当promise数组中所有的promise都成功才resolve, 而只要其中一个失败就直接reject失败的结果
const p1 = new Promise((resolve, reject) => {
setTimeout(() => {
resolve(111);
}, 2000);
});
const p2 = new Promise((resolve, reject) => {
setTimeout(() => {
resolve(222);
}, 1000);
});
const p3 = new Promise((resolve, reject) => {
setTimeout(() => {
resolve(333);
}, 3000);
});
Promise.all([p1, p2, p3]).then(
(res) => {
console.log(res);
},
(err) => {
console.log(err);
}
);
Promise._all = function (promises) {
return new Promise((resolve, reject) => {
let results = [];
promises.forEach((promise, index) => {
promise.then(
(res) => {
// 加个索引就可以知道是哪个promise的结果
results.push({ res, index });
if (results.length === promises.length) {
resolve(results);
}
},
(err) => {
reject(err);
}
);
});
});
};
Promise._all([p1, p2, p3]).then(
(res) => {
console.log(res);
},
(err) => {
console.log(err);
}
); |
Promise.all = function (...args) {
return new Promise((resolve, reject) => {
try {
const result = []
let count = 0
const len = args.length
args.forEach((item, i) => {
Promise.resolve(item).then(res => {
result[i] = res
count++
if (len === count) {
resolve(result)
}
}).catch((err) => {
reject(err)
})
})
} catch (error) {
reject(error)
}
})
} |
|
|
No description provided.
The text was updated successfully, but these errors were encountered: