考虑下面以串行/顺序方式读取文件数组的代码。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);
}));
};
这是上面另一个答案的轻微变化。使用原生承诺:
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(...)
首先，您需要了解承诺是在创建时执行的。
例如，如果你有一个代码:
["a","b","c"].map(x => returnsPromise(x))
您需要更改为:
["a","b","c"].map(x => () => returnsPromise(x))
然后，我们需要按顺序链接承诺:
["a", "b", "c"].map(x => () => returnsPromise(x))
.reduce(
(before, after) => before.then(_ => after()),
Promise.resolve()
)
执行after()，将确保只有在promise到期时才创建(并执行)promise。
我不得不运行大量的顺序任务，并使用这些答案来伪造一个函数，将照顾处理任何顺序任务…
function one_by_one(objects_array, iterator, callback) {
var start_promise = objects_array.reduce(function (prom, object) {
return prom.then(function () {
return iterator(object);
});
}, Promise.resolve()); // initial
if(callback){
start_promise.then(callback);
}else{
return start_promise;
}
}
该函数接受2个参数+ 1个可选参数。第一个参数是我们将要处理的数组。第二个参数是任务本身，一个返回承诺的函数，只有当这个承诺解决时，下一个任务才会开始。第三个参数是在所有任务完成后运行的回调。如果没有传递回调，则函数返回它创建的promise，以便我们可以处理结束。
下面是一个用法示例:
var filenames = ['1.jpg','2.jpg','3.jpg'];
var resize_task = function(filename){
//return promise of async resizing with filename
};
one_by_one(filenames,resize_task );
希望它能节省一些时间…
(function() {
function sleep(ms) {
return new Promise(function(resolve) {
setTimeout(function() {
return resolve();
}, ms);
});
}
function serial(arr, index, results) {
if (index == arr.length) {
return Promise.resolve(results);
}
return new Promise(function(resolve, reject) {
if (!index) {
index = 0;
results = [];
}
return arr[index]()
.then(function(d) {
return resolve(d);
})
.catch(function(err) {
return reject(err);
});
})
.then(function(result) {
console.log("here");
results.push(result);
return serial(arr, index + 1, results);
})
.catch(function(err) {
throw err;
});
}
const a = [5000, 5000, 5000];
serial(a.map(x => () => sleep(x)));
})();
这里的关键是如何调用sleep函数。你需要传递一个函数数组，它本身返回一个promise，而不是一个promise数组。
这是我在各种项目中使用的顺序实现:
const file = [file1, file2, file3];
const fileContents = sequentially(readFile, files);
// somewhere else in the code:
export const sequentially = async <T, P>(
toPromise: (element: T) => Promise<P>,
elements: T[]
): Promise<P[]> => {
const results: P[] = [];
await elements.reduce(async (sequence, element) => {
await sequence;
results.push(await toPromise(element));
}, Promise.resolve());
return results;
};
