我一直在用for来求解连续的承诺。我不确定这是否有帮助，但这就是我一直在做的。

async function run() {
    for (let val of arr) {
        const res = await someQuery(val)
        console.log(val)
    }
}

run().then().catch()

你可以通过for循环来实现。

Async函数返回承诺:

async function createClient(client) {
    return await Client.create(client);
}

let clients = [client1, client2, client3];

如果你写下面的代码，那么客户端是并行创建的:

const createdClientsArray = yield Promise.all(clients.map((client) =>
    createClient(client);
));

但是如果你想按顺序创建客户端，那么你应该使用for循环:

const createdClientsArray = [];
for(let i = 0; i < clients.length; i++) {
    const createdClient = yield createClient(clients[i]);
    createdClientsArray.push(createdClient);
}

NodeJS不是并行运行承诺，而是并发运行，因为它是一个单线程事件循环架构。有可能通过创建一个新的子进程来利用多核CPU来并行运行。

并行Vs并发

其实，什么承诺。所做的就是，将Promise函数堆叠在适当的队列中(参见事件循环架构)，并发运行它们(调用P1, P2，…)，然后等待每个结果，然后解析Promise。所有的许诺都有结果。 的承诺。所有人都会在第一次承诺时失败，除非你必须自己处理拒绝。

并行和并发有一个很大的区别，第一个会在完全相同的时间在一个单独的进程中运行不同的计算，它们会按照自己的节奏进行，而另一个会一个接一个地执行不同的计算，而不需要等待前一个计算完成并同时进行，而不依赖彼此。

最后，回答你的问题，我保证。所有这些都不是并行或顺序执行，而是并发执行。

并行

await Promise.all(items.map(async (item) => { 
  await fetchItem(item) 
}))

优点:速度更快。所有的迭代都将启动，即使其中一个在以后失败。然而，它会“快速失败”。使用的承诺。allsettle，即使某些迭代失败，也要并行地完成所有迭代。从技术上讲，这些是并发调用，而不是并行调用。

按顺序

for (const item of items) {
  await fetchItem(item)
}

优点:循环中的变量可以在每次迭代中共享。行为类似于普通的命令式同步代码。

也可以使用递归函数用异步函数顺序处理可迭代对象。例如，给定一个数组a，使用异步函数someAsyncFunction()处理:

var a = [1, 2, 3, 4, 5, 6] function someAsyncFunction(n) { return new Promise((resolve, reject) => { setTimeout(() => { console.log("someAsyncFunction: ", n) resolve(n) }, Math.random() * 1500) }) } //You can run each array sequentially with: function sequential(arr, index = 0) { if (index >= arr.length) return Promise.resolve() return someAsyncFunction(arr[index]) .then(r => { console.log("got value: ", r) return sequential(arr, index + 1) }) } sequential(a).then(() => console.log("done"))

Promise.all(iterable)执行所有承诺吗?

不，承诺不能“执行”。它们在创建时就开始执行任务——它们只表示结果——甚至在将它们传递给Promise.all之前，您就可以并行执行所有的任务。

的承诺。一切都只等着多次承诺。它不关心它们解析的顺序，也不关心计算是否在并行运行。

是否有一种方便的方法来连续运行一个可迭代对象?

如果你已经许下承诺，除了承诺，你别无他法。All ([p1, p2, p3，…])(没有序列概念)。但是如果你确实有一个异步函数的可迭代对象，你确实可以按顺序运行它们。基本上你需要从

[fn1, fn2, fn3, …]

to

fn1().then(fn2).then(fn3).then(…)

解决方案是使用Array::reduce:

iterable.reduce((p, fn) => p.then(fn), Promise.resolve())