请考虑以下以串行/顺序方式读取文件数组的代码。 readFiles返回一个promise，只有在按顺序读取所有文件后才会解析。
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!
});
};
上面的代码有效，但我不喜欢按顺序进行递归递归。是否有一种更简单的方法可以重写此代码，以便我不必使用我奇怪的readSequential函数？
最初我尝试使用Promise.all，但这导致所有readFile调用同时发生，这是不我想要的：
var readFiles = function(files) {
return Promise.all(files.map(function(file) {
return readFile(file);
}));
};
答案 0 :(得分：250)
2017年更新：如果环境支持，我会使用异步功能：
async function readFiles(files) {
for(const file of files) {
await readFile(file);
}
};
如果您愿意，可以推迟阅读文件，直到您需要使用异步生成器（如果您的环境支持它）：
async function* readFiles(files) {
for(const file of files) {
yield await readFile(file);
}
};
更新：第二个想法 - 我可能会使用for循环：
var readFiles = function(files) {
var p = Promise.resolve(); // Q() in q
files.forEach(file =>
p = p.then(() => readFile(file));
);
return p;
};
或更紧凑，使用reduce：
var readFiles = function(files) {
return files.reduce((p, file) => {
return p.then(() => readFile(file));
}, Promise.resolve()); // initial
};
在其他的promise库中（比如when和Bluebird）你有实用的方法。
例如，Bluebird将是：
var Promise = require("bluebird");
var fs = Promise.promisifyAll(require("fs"));
var readAll = Promise.resolve(files).map(fs.readFileAsync,{concurrency: 1 });
// if the order matters, you can use Promise.each instead and omit concurrency param
readAll.then(function(allFileContents){
// do stuff to read files.
});
虽然 确实没有理由今天使用异步等待。
答案 1 :(得分：62)
Here is how I prefer to run tasks in series.
function runSerial() {
var that = this;
// task1 is a function that returns a promise (and immediately starts executing)
// task2 is a function that returns a promise (and immediately starts executing)
return Promise.resolve()
.then(function() {
return that.task1();
})
.then(function() {
return that.task2();
})
.then(function() {
console.log(" ---- done ----");
});
}
What about cases with more tasks? Like, 10?
function runSerial(tasks) {
var result = Promise.resolve();
tasks.forEach(task => {
result = result.then(() => task());
});
return result;
}
答案 2 :(得分：50)
这个问题很老，但我们生活在ES6和功能JavaScript的世界中，所以让我们看看我们如何改进。
因为承诺立即执行，我们不能创建一个承诺数组，它们都将并行启动。
相反，我们需要创建一个返回promise的函数数组。然后每个函数将按顺序执行，然后启动内部的承诺。
我们可以通过几种方式解决这个问题，但我最喜欢的方法是使用reduce。
使用reduce与承诺相结合有点棘手，所以我将下面的一个衬里分解成了一些较小的可消化食物。
此函数的本质是使用reduce从初始值Promise.resolve([])开始，或使用包含空数组的promise。
然后，此承诺将作为reduce传递到promise方法。这是按顺序将每个承诺链接在一起的关键。下一个执行的承诺是func，当then触发时，结果会被连接，然后返回该承诺，执行带有下一个promise函数的reduce循环。
一旦所有承诺都执行完毕，返回的承诺将包含每个承诺的所有结果的数组。
ES6示例（一个班轮）
/*
* serial executes Promises sequentially.
* @param {funcs} An array of funcs that return promises.
* @example
* const urls = ['/url1', '/url2', '/url3']
* serial(urls.map(url => () => $.ajax(url)))
* .then(console.log.bind(console))
*/
const serial = funcs =>
funcs.reduce((promise, func) =>
promise.then(result => func().then(Array.prototype.concat.bind(result))), Promise.resolve([]))
ES6示例（细分）
// broken down to for easier understanding
const concat = list => Array.prototype.concat.bind(list)
const promiseConcat = f => x => f().then(concat(x))
const promiseReduce = (acc, x) => acc.then(promiseConcat(x))
/*
* serial executes Promises sequentially.
* @param {funcs} An array of funcs that return promises.
* @example
* const urls = ['/url1', '/url2', '/url3']
* serial(urls.map(url => () => $.ajax(url)))
* .then(console.log.bind(console))
*/
const serial = funcs => funcs.reduce(promiseReduce, Promise.resolve([]))
用法：
// first take your work
const urls = ['/url1', '/url2', '/url3', '/url4']
// next convert each item to a function that returns a promise
const funcs = urls.map(url => () => $.ajax(url))
// execute them serially
serial(funcs)
.then(console.log.bind(console))
答案 3 :(得分：35)
仅在ES6中执行此操作：
function(files) {
// Create a new empty promise (don't do that with real people ;)
var sequence = Promise.resolve();
// Loop over each file, and add on a promise to the
// end of the 'sequence' promise.
files.forEach(function(file) {
// Chain one computation onto the sequence
sequence = sequence.then(function() {
return performComputation(file);
}).then(function(result) {
doSomething(result) // Resolves for each file, one at a time.
});
})
// This will resolve after the entire chain is resolved
return sequence;
}
答案 4 :(得分：23)
标准Node.js承诺的简单实用程序：
function sequence(tasks, fn) {
return tasks.reduce((promise, task) => promise.then(() => fn(task)), Promise.resolve());
}
<强>更新
items-promise是一个随时可用的NPM软件包。
答案 5 :(得分：11)
我必须运行很多顺序任务，并使用这些答案来伪造一个能够处理任何顺序任务的函数......
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的函数，下一个任务只有在这个promise解析时才会启动。第三个参数是在完成所有任务后运行的回调。如果没有传递回调，则该函数返回它创建的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 );
希望能节省一些时间......
答案 6 :(得分：4)
我能够弄清楚的最好的解决方案是bluebird承诺。你可以Promise.resolve(files).each(fs.readFileAsync);来保证承诺按顺序按顺序解决。
答案 7 :(得分：4)
我的首选解决方案：
function processArray(arr, fn) {
return arr.reduce(
(p, v) => p.then((a) => fn(v).then(r => a.concat([r]))),
Promise.resolve([])
);
}
与其他人发布的内容并没有根本的区别，但是：
使用示例：
const numbers = [0, 4, 20, 100];
const multiplyBy3 = (x) => new Promise(res => res(x * 3));
// Prints [ 0, 12, 60, 300 ]
processArray(numbers, multiplyBy3).then(console.log);
在合理的当前Chrome（v59）和NodeJS（v8.1.2）上进行测试。
答案 8 :(得分：4)
这是上面另一个答案的略微变化。使用本机Promise：
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(...)
答案 9 :(得分：3)
使用Array.prototype.reduce，并记住将你的承诺包装在一个函数中，否则它们已经在运行！
// array of Promise providers
const providers = [
function(){
return Promise.resolve(1);
},
function(){
return Promise.resolve(2);
},
function(){
return Promise.resolve(3);
}
]
const inSeries = function(providers){
const seed = Promise.resolve(null);
return providers.reduce(function(a,b){
return a.then(b);
}, seed);
};
美好而轻松...... 你应该能够重复使用相同的种子来表现等等。
使用reduce 时，防止空数组或仅包含1个元素的数组非常重要，所以这种技巧是你最好的选择：
const providers = [
function(v){
return Promise.resolve(v+1);
},
function(v){
return Promise.resolve(v+2);
},
function(v){
return Promise.resolve(v+3);
}
]
const inSeries = function(providers, initialVal){
if(providers.length < 1){
return Promise.resolve(null)
}
return providers.reduce((a,b) => a.then(b), providers.shift()(initialVal));
};
然后将其称为：
inSeries(providers, 1).then(v => {
console.log(v); // 7
});
答案 10 :(得分：2)
您可以使用此函数获取promiseFactories List：
function executeSequentially(promiseFactories) {
var result = Promise.resolve();
promiseFactories.forEach(function (promiseFactory) {
result = result.then(promiseFactory);
});
return result;
}
Promise Factory只是一个返回Promise的简单函数：
function myPromiseFactory() {
return somethingThatCreatesAPromise();
}
这是有效的，因为承诺工厂在被要求之前不会创造承诺。它的工作方式与当时的功能相同 - 实际上，它的功能相同！
你根本不想操作一系列的承诺。根据Promise规范，一旦创建了promise，它就会开始执行。所以你真正想要的是一系列承诺工厂......
如果您想了解有关Promises的更多信息，请查看以下链接： https://pouchdb.com/2015/05/18/we-have-a-problem-with-promises.html
答案 11 :(得分：2)
有了 ES2016 的 async/await（也许还有 ES2018 的一些特性），这可以简化为这种形式：
function readFile(file) {
... // Returns a promise.
}
async function readFiles(files) {
for (file in files) {
await readFile(file)
}
}
我还没有看到另一个答案表达了这种简单性。 OP 表示不需要并行执行 readFile。但是，对于这样的 IO，在单个文件读取时不阻塞真的很有意义，同时保持循环执行同步（您不想在读取所有文件之前执行下一步）。由于我刚刚了解到这一点并且对此感到有些兴奋，因此我将分享 readFile 的并行异步执行与 readFiles 的整体同步执行的方法。
async function readFiles(files) {
await Promise.all(files.map(readFile))
}
这难道不是一种美吗？
答案 12 :(得分：2)
我的答案基于https://stackoverflow.com/a/31070150/7542429。
Promise.series = function series(arrayOfPromises) {
var results = [];
return arrayOfPromises.reduce(function(seriesPromise, promise) {
return seriesPromise.then(function() {
return promise
.then(function(result) {
results.push(result);
});
});
}, Promise.resolve())
.then(function() {
return results;
});
};
此解决方案将结果作为Promise.all（）等数组返回。
用法：
Promise.series([array of promises])
.then(function(results) {
// do stuff with results here
});
答案 13 :(得分：2)
我在Promise对象上创建了这个简单的方法：
Promise.sequence = function (chain) {
var results = [];
var entries = chain;
if (entries.entries) entries = entries.entries();
return new Promise(function (yes, no) {
var next = function () {
var entry = entries.next();
if(entry.done) yes(results);
else {
results.push(entry.value[1]().then(next, function() { no(results); } ));
}
};
next();
});
};
var todo = [];
todo.push(firstPromise);
if (someCriterium) todo.push(optionalPromise);
todo.push(lastPromise);
// Invoking them
Promise.sequence(todo)
.then(function(results) {}, function(results) {});
Promise对象扩展的最佳之处在于它与promises的风格一致。 Promise.all和Promise.sequence以相同的方式调用，但具有不同的语义。
承诺的顺序运行通常不是使用承诺的好方法。使用Promise.all通常更好，让浏览器尽可能快地运行代码。但是，它有真实的用例 - 例如在使用javascript编写移动应用程序时。
答案 14 :(得分：2)
我真的很喜欢@ joelnet的答案，但对我来说，这种编码方式有点难以消化，所以我花了几天的时间试图找出如何在一个表达同样的解决方案这是我的看法，只是使用不同的语法和一些注释。
// first take your work
const urls = ['/url1', '/url2', '/url3', '/url4']
// next convert each item to a function that returns a promise
const functions = urls.map((url) => {
// For every url we return a new function
return () => {
return new Promise((resolve) => {
// random wait in milliseconds
const randomWait = parseInt((Math.random() * 1000),10)
console.log('waiting to resolve in ms', randomWait)
setTimeout(()=>resolve({randomWait, url}),randomWait)
})
}
})
const promiseReduce = (acc, next) => {
// we wait for the accumulator to resolve it's promise
return acc.then((accResult) => {
// and then we return a new promise that will become
// the new value for the accumulator
return next().then((nextResult) => {
// that eventually will resolve to a new array containing
// the value of the two promises
return accResult.concat(nextResult)
})
})
};
// the accumulator will always be a promise that resolves to an array
const accumulator = Promise.resolve([])
// we call reduce with the reduce function and the accumulator initial value
functions.reduce(promiseReduce, accumulator)
.then((result) => {
// let's display the final value here
console.log('=== The final result ===')
console.log(result)
})
答案 15 :(得分：2)
正如Bergi所注意到的，我认为最好，最清晰的解决方案是使用BlueBird.each，以下代码：
const BlueBird = require('bluebird');
BlueBird.each(files, fs.readFileAsync);
答案 16 :(得分：1)
我使用以下代码来扩展Promise对象。它处理拒绝承诺并返回一系列结果
<强>代码
/*
Runs tasks in sequence and resolves a promise upon finish
tasks: an array of functions that return a promise upon call.
parameters: an array of arrays corresponding to the parameters to be passed on each function call.
context: Object to use as context to call each function. (The 'this' keyword that may be used inside the function definition)
*/
Promise.sequence = function(tasks, parameters = [], context = null) {
return new Promise((resolve, reject)=>{
var nextTask = tasks.splice(0,1)[0].apply(context, parameters[0]); //Dequeue and call the first task
var output = new Array(tasks.length + 1);
var errorFlag = false;
tasks.forEach((task, index) => {
nextTask = nextTask.then(r => {
output[index] = r;
return task.apply(context, parameters[index+1]);
}, e=>{
output[index] = e;
errorFlag = true;
return task.apply(context, parameters[index+1]);
});
});
// Last task
nextTask.then(r=>{
output[output.length - 1] = r;
if (errorFlag) reject(output); else resolve(output);
})
.catch(e=>{
output[output.length - 1] = e;
reject(output);
});
});
};
示例
function functionThatReturnsAPromise(n) {
return new Promise((resolve, reject)=>{
//Emulating real life delays, like a web request
setTimeout(()=>{
resolve(n);
}, 1000);
});
}
var arrayOfArguments = [['a'],['b'],['c'],['d']];
var arrayOfFunctions = (new Array(4)).fill(functionThatReturnsAPromise);
Promise.sequence(arrayOfFunctions, arrayOfArguments)
.then(console.log)
.catch(console.error);
答案 17 :(得分：1)
如果您愿意，可以使用reduce来制作顺序承诺，例如：
[2,3,4,5,6,7,8,9].reduce((promises, page) => {
return promises.then((page) => {
console.log(page);
return Promise.resolve(page+1);
});
}, Promise.resolve(1));
它总是按顺序工作。
答案 18 :(得分：1)
我不明白为什么人们会提出如此复杂的解决方案。这是一个更简单的逻辑
function downloadFile(fileUrl) { ... } // This function return a Promise
async function main()
{
var filesList = [...];
for (var i = 0; i <= filesList.length; i++)
{
await downloadFile(filesList[i]);
}
}
function downloadFile(fileUrl) { ... } // This function return a Promise
function downloadRecursion(filesList, index)
{
if (index < filesList.length)
{
downloadFile(filesList[index]).then(function()
{
index++;
downloadRecursion(filesList, index); // self invocation - recursion!
});
}
else
{
return Promise.resolve();
}
}
function main()
{
var filesList = [...];
downloadFile(filesList, 0);
}
答案 19 :(得分：1)
大多数答案都不包括单独的ALL承诺的结果，因此，如果有人正在寻找这种特殊行为，这是使用递归的一种可能的解决方案。
它遵循Promise.all的样式：
返回.then()回调中的结果数组。
如果某些承诺失败，则其会立即在.catch()回调中返回。
const promiseEach = (arrayOfTasks) => {
let results = []
return new Promise((resolve, reject) => {
const resolveNext = (arrayOfTasks) => {
// If all tasks are already resolved, return the final array of results
if (arrayOfTasks.length === 0) return resolve(results)
// Extract first promise and solve it
const first = arrayOfTasks.shift()
first().then((res) => {
results.push(res)
resolveNext(arrayOfTasks)
}).catch((err) => {
reject(err)
})
}
resolveNext(arrayOfTasks)
})
}
// Lets try it ?
const promise = (time, shouldThrowError) => new Promise((resolve, reject) => {
const timeInMs = time * 1000
setTimeout(()=>{
console.log(`Waited ${time} secs`)
if (shouldThrowError) reject(new Error('Promise failed'))
resolve(time)
}, timeInMs)
})
const tasks = [() => promise(1), () => promise(2)]
promiseEach(tasks)
.then((res) => {
console.log(res) // [1, 2]
})
// Oops some promise failed
.catch((error) => {
console.log(error)
})
关于tasks数组声明的注释：
在这种情况下，无法像Promise.all这样使用以下符号：
const tasks = [promise(1), promise(2)]
我们必须使用：
const tasks = [() => promise(1), () => promise(2)]
原因是JavaScript在声明后立即开始执行promise。如果我们使用类似Promise.all的方法，它只会检查所有状态是否为fulfilled或rejected，而不会启动执行本身。使用() => promise()，我们将停止执行直到被调用。
答案 20 :(得分：0)
这是我在各种项目中使用的 sequentially 实现：
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;
};
答案 21 :(得分：0)
nodejs 中有 promise-sequence。
const promiseSequence = require('promise-sequence');
return promiseSequence(arr.map(el => () => doPromise(el)));
答案 22 :(得分：0)
(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)));
})();
这里的关键是如何调用睡眠功能。您需要传递一个函数数组，该函数本身返回一个promise，而不是一个promise数组。
答案 23 :(得分：0)
首先，您需要了解在创建时已执行了承诺。
例如，如果您有一个代码：
["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。
答案 24 :(得分：0)
使用现代ES：
const series = async (tasks) => {
const results = [];
for (const task of tasks) {
const result = await task;
results.push(result);
}
return results;
};
//...
const readFiles = await series(files.map(readFile));
答案 25 :(得分：0)
数组push和pop方法可用于promise序列。您还可以在需要其他数据时提出新的承诺。这是代码，我将在React Infinite加载程序中使用该代码加载页面序列。
var promises = [Promise.resolve()];
function methodThatReturnsAPromise(page) {
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log(`Resolve-${page}! ${new Date()} `);
resolve();
}, 1000);
});
}
function pushPromise(page) {
promises.push(promises.pop().then(function () {
return methodThatReturnsAPromise(page)
}));
}
pushPromise(1);
pushPromise(2);
pushPromise(3);
答案 26 :(得分：0)
如果其他人在执行CRUD操作时需要严格的顺序解决承诺的方式，您还可以使用以下代码作为基础。
只要在调用每个函数之前添加“ return”，描述一个Promise，并以此示例为基础，下一个.then（）函数调用将在上一个函数完成后始终开始：
getRidOfOlderShoutsPromise = () => {
return readShoutsPromise('BEFORE')
.then(() => {
return deleteOlderShoutsPromise();
})
.then(() => {
return readShoutsPromise('AFTER')
})
.catch(err => console.log(err.message));
}
deleteOlderShoutsPromise = () => {
return new Promise ( (resolve, reject) => {
console.log("in deleteOlderShouts");
let d = new Date();
let TwoMinuteAgo = d - 1000 * 90 ;
All_Shouts.deleteMany({ dateTime: {$lt: TwoMinuteAgo}}, function(err) {
if (err) reject();
console.log("DELETED OLDs at "+d);
resolve();
});
});
}
readShoutsPromise = (tex) => {
return new Promise( (resolve, reject) => {
console.log("in readShoutsPromise -"+tex);
All_Shouts
.find({})
.sort([['dateTime', 'ascending']])
.exec(function (err, data){
if (err) reject();
let d = new Date();
console.log("shouts "+tex+" delete PROMISE = "+data.length +"; date ="+d);
resolve(data);
});
});
}
答案 27 :(得分：0)
根据问题的标题，＆＃34;一个接一个地解决承诺（即按顺序）？＆＃34;，我们可能会理解OP对承诺的顺序处理更感兴趣在结算而不是顺序电话本身。
提供了这个答案：
如果真的不想要并发通话，请参阅Benjamin Gruenbaum的回答，该回答涵盖顺序通话（等）。
但是，如果您感兴趣（为了提高性能）允许并发调用然后顺序处理响应的模式，那么请继续阅读。
很有想象你必须使用Promise.all(arr.map(fn)).then(fn)（就像我已多次做过的那样）或使用Promise lib的花式糖（尤其是蓝鸟）（但是归功于this article）arr.map(fn).reduce(fn)模式将完成这项工作，具有以下优势：
.then()。这是为Q编写的。
var readFiles = function(files) {
return files.map(readFile) //Make calls in parallel.
.reduce(function(sequence, filePromise) {
return sequence.then(function() {
return filePromise;
}).then(function(file) {
//Do stuff with file ... in the correct sequence!
}, function(error) {
console.log(error); //optional
return sequence;//skip-over-error. To stop-on-error, `return error` (jQuery), or `throw error` (Promises/A+).
});
}, Q()).then(function() {
// all done.
});
};
注意：只有一个片段Q()特定于Q.对于jQuery，您需要确保readFile（）返回jQuery promise。有了A + libs，外国的承诺就会被同化。
这里的关键是缩减sequence承诺，它会对readFile承诺的处理进行排序，但不会创建它们。
一旦你吸收了它，当你意识到.map()阶段实际上并不是必需的时候，它可能会略显令人兴奋！整个工作，并行调用以及正确顺序的串行处理，只需reduce()就可以实现，还有进一步灵活性的附加优势：
这是Q再次。
var readFiles = function(files) {
return files.reduce(function(sequence, f) {
var filePromise = readFile(f);//Make calls in parallel. To call sequentially, move this line down one.
return sequence.then(function() {
return filePromise;
}).then(function(file) {
//Do stuff with file ... in the correct sequence!
}, function(error) {
console.log(error); //optional
return sequence;//Skip over any errors. To stop-on-error, `return error` (jQuery), or `throw error` (Promises/A+).
});
}, Q()).then(function() {
// all done.
});
};
这是基本模式。如果您还想将数据（例如文件或它们的某些变换）传递给调用者，则需要一个温和的变体。
答案 28 :(得分：0)
你的方法并不错，但它确实有两个问题：它吞下错误并使用Explicit Promise Construction Antipattern。
您可以解决这两个问题，并使代码更清晰，同时仍采用相同的一般策略：
var Q = require("q");
var readFile = function(file) {
... // Returns a promise.
};
var readFiles = function(files) {
var readSequential = function(index) {
if (index < files.length) {
return readFile(files[index]).then(function() {
return readSequential(index + 1);
});
}
};
// using Promise.resolve() here in case files.length is 0
return Promise.resolve(readSequential(0)); // Start!
};
答案 29 :(得分：-2)
这是为了扩展如何以更通用的方式处理一系列承诺，支持基于spex.sequence实现的动态/无限序列：
var $q = require("q");
var spex = require('spex')($q);
var files = []; // any dynamic source of files;
var readFile = function (file) {
// returns a promise;
};
function source(index) {
if (index < files.length) {
return readFile(files[index]);
}
}
function dest(index, data) {
// data = resolved data from readFile;
}
spex.sequence(source, dest)
.then(function (data) {
// finished the sequence;
})
.catch(function (error) {
// error;
});
此解决方案不仅适用于任何大小的序列，而且您可以轻松地向其添加data throttling and load balancing。