只需使用.then(resPrevTask => nextTask())

(顺便说一下，下一个代码需要4秒。)

函数task1() { return new Promise((resolve) => { setTimeout(() => { 解决(console.log(任务1)) }, 3000) }） ｝ 函数task2() { return new Promise((resolve) => { setTimeout(() => { 解决(console.log(任务2)) }, 1000) }） ｝ 函数seqTasks () { task1 () .then(() => task2()) ｝ seqTasks ();

这是我在各种项目中使用的顺序实现:

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

根据问题的标题“一个接一个地(即顺序地)解决承诺?”，我们可以理解为OP更感兴趣的是对结算承诺的顺序处理，而不是顺序调用本身。

给出的答案是:

演示顺序调用对于响应的顺序处理是不必要的。 向本页的访问者展示可行的替代模式——包括OP，如果他在一年后仍然感兴趣的话。 尽管OP断言他不想同时拨打电话，这可能是真的，但同样也可能是基于标题所暗示的对连续处理响应的渴望的假设。

如果并发调用真的不需要，那么请参阅Benjamin Gruenbaum的回答，其中全面涵盖了顺序调用(等等)。

但是，如果您对允许并发调用然后依次处理响应的模式感兴趣(为了提高性能)，那么请继续阅读。

你很容易认为你必须使用Promise.all(arr.map(fn)).then(fn)(我已经做过很多次了)或Promise库的花哨糖(尤其是Bluebird的)，然而(这篇文章的功劳)arr.map(fn).reduce(fn)模式将完成这项工作，其优点是:

适用于任何承诺库——甚至是预兼容版本的jQuery——只使用.then()。 提供了灵活性，跳过错误或停止错误，无论你想用一行mod。

这就是，为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承诺。有了A+，国外的承诺就会被同化。

这里的关键是还原的序列承诺，它对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.
    });
};

这是基本模式。如果您还想向调用者交付数据(例如文件或它们的一些转换)，则需要一个温和的变体。

使用ES2016的async/await(可能还有ES2018的一些特性)，这可以简化为这样的形式:

function readFile(file) {
  ... // Returns a promise.
}

async function readFiles(files) {
  for (file in files) {
     await readFile(file)
  }
}

I haven't seen another answer express that simplicity. The OP said parallel execution of readFile was not desired. However, with IO like this it really makes sense to not be blocking on a single file read, while keeping the loop execution synchronous (you don't want to do the next step until all files have been read). Since I just learned about this and am a bit excited about it, I'll share that approach of parallel asynchronous execution of readFile with overall synchronous execution of readFiles.

async function readFiles(files) {
  await Promise.all(files.map(readFile))
}

这难道不是一件美好的事情吗?

你可以使用这个函数来获取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();
}

它之所以有效，是因为承诺工厂直到被要求才创建承诺。它的工作方式与then函数相同——事实上，它是一样的!

你根本不想在一组承诺上操作。根据Promise规范，一旦创建了Promise，它就开始执行。所以你真正想要的是一系列的承诺工厂…

如果你想了解更多的承诺，你应该检查这个链接: https://pouchdb.com/2015/05/18/we-have-a-problem-with-promises.html

数组push和pop方法可用于承诺序列。当你需要额外的数据时，你也可以推出新的承诺。这是代码，我将使用在React无限加载器加载页面序列。

var promises = [Promise.resolve()]; 函数methodThatReturnsAPromise(page) { 返回新的承诺((resolve, reject) => { setTimeout(() => { console.log(“解决- ${页面}!${new Date()} '); 解决(); }, 1000); })； ｝ 函数pushPromise(page) { promises.push (promises.pop()。然后(function () { 返回methodThatReturnsAPromise(页面) })); ｝ pushPromise (1); pushPromise (2); pushPromise (3);