考虑下面以串行/顺序方式读取文件数组的代码。readFiles返回一个承诺，只有在顺序读取所有文件后才会解析这个承诺。
var readFile = function(file) {
... // Returns a promise.
};
var readFiles = function(files) {
return new Promise((resolve, reject) => {
var readSequential = function(index) {
if (index >= files.length) {
resolve();
} else {
readFile(files[index]).then(function() {
readSequential(index + 1);
}).catch(reject);
}
};
readSequential(0); // Start with the first file!
});
};
上面的代码可以工作，但是我不喜欢为了使事情按顺序发生而进行递归。是否有一种更简单的方法可以重写这段代码，这样我就不必使用奇怪的readSequential函数了?
最初我尝试使用Promise。但是这会导致所有的readFile调用并发发生，这不是我想要的:
var readFiles = function(files) {
return Promise.all(files.map(function(file) {
return readFile(file);
}));
};
使用Async/Await(如果你有ES7的支持)
function downloadFile(fileUrl) { ... } // This function return a Promise
async function main()
{
var filesList = [...];
for (const file of filesList) {
await downloadFile(file);
}
}
(你必须使用for循环，而不是forEach，因为async/await在forEach循环中运行有问题)
没有Async/Await(使用Promise)
function downloadFile(fileUrl) { ... } // This function return a Promise
function downloadRecursion(filesList, index)
{
index = index || 0;
if (index < filesList.length)
{
downloadFile(filesList[index]).then(function()
{
index++;
downloadRecursion(filesList, index); // self invocation - recursion!
});
}
else
{
return Promise.resolve();
}
}
function main()
{
var filesList = [...];
downloadRecursion(filesList);
}
另外的例子
const addTwo = async () => 2;
const addThree = async (inValue) => new Promise((resolve) => setTimeout(resolve(inValue + 3), 2000));
const addFour = (inValue) => new Promise((res) => setTimeout(res(inValue + 4), 1000));
const addFive = async (inValue) => inValue + 5;
// Function which handles promises from above
async function sequenceAddition() {
let sum = await [addTwo, addThree, addFour, addFive].reduce(
(promise, currPromise) => promise.then((val) => currPromise(val)),
Promise.resolve()
);
console.log('sum:', sum); // 2 + 3 + 4 + 5 = 14
}
// Run function. See console for result.
sequenceAddition();
使用reduce()的通用语法
function sequence(tasks, fn) {
return tasks.reduce((promise, task) => promise.then(() => fn(task)), Promise.resolve());
}
更新
items-promise是一个准备使用NPM包做同样的事情。
这是上面另一个答案的轻微变化。使用原生承诺:
function inSequence(tasks) {
return tasks.reduce((p, task) => p.then(task), Promise.resolve())
}
解释
如果你有这些任务[t1, t2, t3]，那么上面的等价于Promise.resolve().then(t1).then(t2).then(t3)。这是约简的行为。
如何使用
首先你需要构造一个任务列表!任务是不接受实参的函数。如果需要将参数传递给函数，则使用bind或其他方法创建任务。例如:
var tasks = files.map(file => processFile.bind(null, file))
inSequence(tasks).then(...)
有一个npm包Promise Serial可以很好地做到这一点:
const Promise_serial = require('promise-serial');
const promises =
Array(15).fill()
.map((_, i) =>
() => new Promise(resolve => {
console.log('promise '+i+' start');
setTimeout(
() => {
console.log('promise '+i+' end');
resolve('output-'+i);
},
500
);
})
);
console.log('### Run promises in sequence')
Promise_serial(promises)
输出:
promise 0 start
promise 0 end
promise 1 start
promise 1 end
promise 2 start
promise 2 end
promise 3 start
promise 3 end
promise 4 start
promise 4 end
promise 5 start
promise 5 end
promise 6 start
promise 6 end
promise 7 start
promise 7 end
... etc
您还可以批处理或并行化它们。
参见:https://www.npmjs.com/package/promise-serial
