是的，您可以按照如下方式链接一个promise返回函数数组 (这将每个函数的结果传递给下一个函数)。当然，您可以编辑它，将相同的参数(或不传递参数)传递给每个函数。

function tester1(a) { return new Promise(function(done) { setTimeout(function() { done(a + 1); }, 1000); }) } function tester2(a) { return new Promise(function(done) { setTimeout(function() { done(a * 5); }, 1000); }) } function promise_chain(args, list, results) { return new Promise(function(done, errs) { var fn = list.shift(); if (results === undefined) results = []; if (typeof fn === 'function') { fn(args).then(function(result) { results.push(result); console.log(result); promise_chain(result, list, results).then(done); }, errs); } else { done(results); } }); } promise_chain(0, [tester1, tester2, tester1, tester2, tester2]).then(console.log.bind(console), console.error.bind(console));

你可以通过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);
}

请看这个示例

的承诺。全部并行工作

const { range, random, forEach, delay} = require("lodash");  
const run = id => {
    console.log(`Start Task ${id}`);
    let prom = new Promise((resolve, reject) => {
        delay(() => {
            console.log(`Finish Task ${id}`);
            resolve(id);
        }, random(2000, 15000));
    });
    return prom;
}


const exec = () => {
    let proms = []; 
    forEach(range(1,10), (id,index) => {
        proms.push(run(id));
    });
    let allPromis = Promise.all(proms); 
    allPromis.then(
        res => { 
            forEach(res, v => console.log(v));
        }
    );
}

exec();

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

Bergi的回答帮助我使电话同步。我在下面添加了一个例子，我们在前面的函数被调用之后调用每个函数:

function func1 (param1) {
    console.log("function1 : " + param1);
}
function func2 () {
    console.log("function2");
}
function func3 (param2, param3) {
    console.log("function3 : " + param2 + ", " + param3);
}

function func4 (param4) {
    console.log("function4 : " + param4);
}
param4 = "Kate";

//adding 3 functions to array

a=[
    ()=>func1("Hi"),
    ()=>func2(),
    ()=>func3("Lindsay",param4)
  ];

//adding 4th function

a.push(()=>func4("dad"));

//below does func1().then(func2).then(func3).then(func4)

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

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

并行Vs并发

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

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

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