考虑以下以串行/顺序方式读取文件数组的代码。readFiles返回一个promise，仅当依次读取所有文件后，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);
  }));
};

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;
};

或更紧凑地使用减少：

var readFiles = function(files) {
  return files.reduce((p, file) => {
     return p.then(() => readFile(file));
  }, Promise.resolve()); // initial
};

在其他Promise库（如when和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.
});

尽管今天确实没有理由不使用异步等待。

这是我更喜欢连续运行任务的方式。

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 ----");
        });
}

有更多任务的情况又如何呢？像十岁吗？

function runSerial(tasks) {
  var result = Promise.resolve();
  tasks.forEach(task => {
    result = result.then(() => task());
  });
  return result;
}

这个问题很古老，但是我们生活在ES6和功能性JavaScript的世界中，所以让我们看看如何改进。

因为promise会立即执行，所以我们不能只创建一个promise数组，它们都会并行触发。

相反，我们需要创建一个返回诺言的函数数组。然后将依次执行每个函数，然后在内部启动Promise。

我们可以通过几种方法解决此问题，但我最喜欢的方法是使用reduce。

reduce与promise结合使用时会有些棘手，因此我将一根衬里分解成下面一些较小的易消化的小块。

此函数的本质是使用reduce以Promise.resolve([])，或包含空数组的诺言开头的初始值。

然后，此承诺将作为传递到reduce方法中promise。这是将每个承诺按顺序链接在一起的关键。下一个要执行的promise是func，当then触发时，将结果连接起来，然后返回该promise，reduce并使用下一个promise函数执行循环。

一旦所有的诺言都已执行，返回的诺言将包含每个诺言的所有结果的数组。

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))

要在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(file => {

    // Chain one computation onto the sequence
    sequence = 
      sequence
        .then(() => performComputation(file))
        .then(result => doSomething(result)); 
        // Resolves for each file, one at a time.

  })

  // This will resolve after the entire chain is resolved
  return sequence;
}

标准Node.js的简单util承诺：

function sequence(tasks, fn) {
    return tasks.reduce((promise, task) => promise.then(() => fn(task)), Promise.resolve());
}

更新

items-promise是准备使用的NPM软件包。

我不得不运行许多顺序任务，并使用这些答案来构建一个可以处理任何顺序任务的功能...

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 );

希望它可以节省一些时间...

我能想到的最好的解决方案是bluebird承诺。您可以做到Promise.resolve(files).each(fs.readFileAsync);保证按顺序依次解决承诺。

这是上面另一个答案的细微变化。使用本机承诺：

function inSequence(tasks) {
    return tasks.reduce((p, task) => p.then(task), Promise.resolve())
}

说明

如果您有这些任务[t1, t2, t3]，则以上内容等同于Promise.resolve().then(t1).then(t2).then(t3)。这是reduce的行为。

如何使用

首先，您需要构造一个任务列表！任务是不接受任何参数的函数。如果需要将参数传递给函数，请使用bind或其他方法来创建任务。例如：

var tasks = files.map(file => processFile.bind(null, file))
inSequence(tasks).then(...)

我的首选解决方案：

function processArray(arr, fn) {
    return arr.reduce(
        (p, v) => p.then((a) => fn(v).then(r => a.concat([r]))),
        Promise.resolve([])
    );
}

它与此处发布的其他文档没有根本区别，但：

• 将功能套用至系列项目
• 解析为一系列结果
• 不需要异步/等待（支持仍然非常有限，大约在2017年）
• 使用箭头功能；简洁明了

用法示例：

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）上进行了测试。

使用Array.prototype.reduce，并记住将您的Promise包装在一个函数中，否则它们将已经运行！

// 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
});

我在Promise对象上创建了以下简单方法：

创建Promise.sequence方法并将其添加到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对象的扩展最好的一点是，它与Promise的样式一致。Promise.all和Promise.sequence的调用方式相同，但语义不同。

警告

顺序运行promise通常不是使用promise的好方法。通常最好使用Promise.all，并让浏览器尽可能快地运行代码。但是，它确实有用例-例如，当使用javascript编写移动应用程序时。

您可以使用此功能获取promiseFactories列表：

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。它与then函数的工作方式相同–实际上，这是同一件事！

您根本不希望兑现一系列承诺。根据Promise规范，一旦创建了承诺，它就会开始执行。所以您真正想要的是一系列承诺工厂...

如果您想了解有关Promises的更多信息，则应查看以下链接：https : //pouchdb.com/2015/05/18/we-have-a-problem-with-promises.html

我的回答基于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
});

我真的很喜欢@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)
  })

正如Bergi所注意到的，我认为最好的和明确的解决方案是使用BlueBird.each，以下代码：

const BlueBird = require('bluebird');
BlueBird.each(files, fs.readFileAsync);

首先，您需要了解在创建时已执行了诺言。
因此，例如，如果您有一个代码：

["a","b","c"].map(x => returnsPromise(x))

您需要将其更改为：

["a","b","c"].map(x => () => returnsPromise(x))

然后，我们需要按顺序链接promise：

["a", "b", "c"].map(x => () => returnsPromise(x))
    .reduce(
        (before, after) => before.then(_ => after()),
        Promise.resolve()
    )

执行after()，将确保仅在承诺到来时创建（并执行）promise。

我使用以下代码扩展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);

如果需要，可以使用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));

它将始终按顺序工作。

使用现代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));

使用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循环中运行时遇到问题）

没有异步/等待（使用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);
}

根据问题标题“解决一个接一个的承诺（即按顺序）？”，我们可能会理解，与按顺序调用本身相比，OP对结算中的按顺序处理承诺更感兴趣。

提供此答案：

• 证明顺序调用对于顺序处理响应不是必需的。
• 向该页面的访问者展示可行的替代模式-包括OP，如果他在一年后仍对此感兴趣。
• 尽管OP声称他不想同时进行呼叫，这确实是真实的情况，但同样可能是基于对标题隐含的对响应进行顺序处理的期望的假设。

如果确实不希望进行并发呼叫，则请参阅本杰明·格伦鲍姆的答案，其中全面涵盖了顺序呼叫（等）。

但是，如果您对允许并发调用并依次处理响应的模式感兴趣（以提高性能），请继续阅读。

人们很容易认为你必须使用Promise.all(arr.map(fn)).then(fn)（因为我已经做过很多次）或无极LIB的幻想糖（尤其是蓝鸟的），但是（以信誉这篇文章）的arr.map(fn).reduce(fn)模式将做的工作，与优点，即：

• 只能与任何promise库一起使用-甚至包括jQuery的预兼容版本.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特定于Q。对于jQuery，您需要确保readFile（）返回jQuery Promise。有了A +库，外国的承诺就会被吸收。

这里的关键是归约的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.
    });
};

这是基本模式。如果您还想将数据（例如文件或文件的某种转换）传递给调用者，则需要一个温和的变体。

您的方法还不错，但是确实有两个问题：它吞没了错误，并且使用了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!
};

如果其他人在执行CRUD操作时需要一种有保证的严格的顺序方式来解决Promises，则还可以使用以下代码作为基础。

只要在调用每个函数之前添加“ 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);
        });    
    });
}

数组推入和弹出方法可用于承诺序列。您还可以在需要其他数据时提出新的承诺。这是代码，我将在React Infinite loader中使用它来加载页面序列。

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);

大多数答案并不包括单独的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()我们停止执行直到被调用。

(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数组。

这将扩展如何基于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;
    });

该解决方案不仅适用于任何大小的序列，而且您可以轻松地为其添加数据限制和负载平衡。