# 如何实现 promise.map，限制 promise 并发数
更多描述
实现一个 promise.map，进行并发数控制，有以下测试用例
pMap([1, 2, 3, 4, 5], (x) => Promise.resolve(x + 1));
pMap([Promise.resolve(1), Promise.resolve(2)], (x) => x + 1);
// 注意输出时间控制
pMap([1, 1, 1, 1, 1, 1, 1, 1], (x) => sleep(1000), { concurrency: 2 });
Issue
欢迎在 Gtihub Issue 中回答此问题: Issue 89 (opens new window)
Author
没人回答
Author
以下代码见 如何实现 promise.map - codepen (opens new window)
function pMap(list, mapper, concurrency = Infinity) {
// list 为 Iterator，先转化为 Array
list = Array.from(list);
return new Promise((resolve, reject) => {
let currentIndex = 0;
let result = [];
let resolveCount = 0;
let len = list.length;
function next() {
const index = currentIndex;
currentIndex++;
Promise.resolve(list[index])
.then((o) => mapper(o, index))
.then((o) => {
result[index] = o;
resolveCount++;
if (resolveCount === len) {
resolve(result);
}
if (currentIndex < len) {
next();
}
});
}
for (let i = 0; i < concurrency && i < len; i++) {
next();
}
});
}
Author
Promise.map = function (queue = [], opt = {}) {
let limit = opt.limit || 5;
let queueIndex = 0;
let completeCount = 0;
let _resolve;
let result = Array(queue.length);
for (let i = 0; i < limit; i++) {
next(queueIndex++);
}
function next(index) {
if (queue.length === 0) return;
let curr = queue.shift();
if (typeof curr === "function") {
curr = curr();
}
Promise.resolve(curr)
.then(
(res) => {
result[index] = res;
},
(res) => {
result[index] = res;
}
)
.finally(() => {
completeCount += 1;
if (completeCount === result.length) {
return _resolve(result);
}
next(queueIndex++);
});
}
return new Promise((resolve) => {
_resolve = resolve;
});
};
function add(a, b) {
return Promise.resolve(a + b);
}
function sum(arr) {
if (arr.length <= 2) {
return add(arr[0] || 0, arr[1] || 0);
}
let mid = (arr.length / 2) | 0;
let promiseArr = [];
for (let i = 0; i < mid; i++) {
promiseArr.push(add(arr[i], arr[mid + i]));
}
return Promise.map(promiseArr).then((res) => {
if (arr.length % 2 !== 0) {
res.push(arr.pop());
}
return sum(res);
});
}
Author
function pMap(list, mapper, cur) {
cur = cur || list.length;
let step = Promise.resolve();
do {
let temp = list.splice(0, cur);
step = step.then(() =>
Promise.all(
temp.map((i, index) => Promise.resolve(i).then((e) => mapper(e, index)))
)
);
} while (list.length);
Author
function pMap([...arr], fn, { concurrency = Infinity } = {}) {
let queue = [],
results = [];
return new Promise((resolve) =>
(function closure() {
const times = concurrency - queue.length;
for (let i = 0; i < times; i++) {
if (!arr.length) return;
const promise = Promise.resolve(arr.shift())
.then(fn)
.then((data) => results.push(data))
.finally(() => {
queue = queue.filter((item) => promise !== item);
if (!queue.length && !arr.length) return resolve(results);
return closure();
});
queue.push(promise);
}
})()
);
}