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）中，您有用于此的实用程序方法。

例如，蓝鸟将是：

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

虽然今天真的没有理由不使用 async await 。

这是我更喜欢按顺序运行任务的方式。

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

有更多任务的案例呢？比如，10？

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

这个问题很老了，但我们生活在 ES6 和函数式 JavaScript 的世界中，所以让我们看看如何改进。

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

相反，我们需要创建一个返回Promise的函数数组。然后每个函数将按顺序执行，然后在里面启动Promise。

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

reduce与 promises 结合使用会有点棘手，所以我将一个衬垫分解成下面一些更小的易消化的食物。

这个函数的本质是使用reduce以 的初始值开始Promise.resolve([])，或者一个包含空数组的Promise。

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

一旦所有 Promise 都执行完毕，返回的 Promise 将包含每个 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 Promise的简单实用程序：

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

更新

items-promise是一个随时可用的 NPM 包，做同样的事情。