如何按顺序执行承诺数组？

Question

我有一系列需要按顺序运行的承诺。

var promises = [promise1, promise2, ..., promiseN];

调用 RSVP.all 将并行执行它们：

RSVP.all(promises).then(...); 

但是，我怎样才能按顺序运行它们呢？

我可以像这样手动堆叠它们

RSVP.resolve()
    .then(promise1)
    .then(promise2)
    ...
    .then(promiseN)
    .then(...);

但问题是承诺的数量各不相同，而且承诺的数组是动态构建的。

Answer 1

如果您已经将它们放在数组中，那么它们已经在执行。 如果你有一个承诺，那么它已经在执行。 这不是.Start()即，在.Start()方法方面，它们不像 C# Task s）。 .all不执行任何操作，它只返回一个 promise。

如果您有一组 promise 返回函数：

var tasks = [fn1, fn2, fn3...];

tasks.reduce(function(cur, next) {
    return cur.then(next);
}, RSVP.resolve()).then(function() {
    //all executed
});

或值：

var idsToDelete = [1,2,3];

idsToDelete.reduce(function(cur, next) {
    return cur.then(function() {
        return http.post("/delete.php?id=" + next);
    });
}, RSVP.resolve()).then(function() {
    //all executed
});

Answer 2

使用 ECMAScript 2017 异步函数，它会像这样完成：

async function executeSequentially() {
    const tasks = [fn1, fn2, fn3]

    for (const fn of tasks) {
        await fn;
    }
}

你现在可以使用BabelJS来使用异步函数了

Answer 3

2017 年的 ES7 方式。

  <script>
  var funcs = [
    _ => new Promise(resolve => setTimeout(_ => resolve("1"), 1000)),
    _ => new Promise(resolve => setTimeout(_ => resolve("2"), 1000)),
    _ => new Promise(resolve => setTimeout(_ => resolve("3"), 1000)),
    _ => new Promise(resolve => setTimeout(_ => resolve("4"), 1000)),
    _ => new Promise(resolve => setTimeout(_ => resolve("5"), 1000)),
    _ => new Promise(resolve => setTimeout(_ => resolve("6"), 1000)),
    _ => new Promise(resolve => setTimeout(_ => resolve("7"), 1000))
  ];
  async function runPromisesInSequence(promises) {
    for (let promise of promises) {
      console.log(await promise());
    }
  }
  </script>
  <button onClick="runPromisesInSequence(funcs)">Do the thing</button>

这将按顺序（一个接一个）执行给定的函数，而不是并行执行。 参数promises是一个函数数组，它返回Promise 。

带有上述代码的 Plunker 示例： http ://plnkr.co/edit/UP0rhD?p=preview

Answer 4

第二次尝试回答，我试图在其中更具解释性：

首先，一些必要的背景，来自RSVP README ：

当您从第一个处理程序返回承诺时，真正令人敬畏的部分出现了......这允许您扁平化嵌套回调，并且是承诺的主要功能，可以防止具有大量异步代码的程序中的“向右漂移”。

这正是你如何按顺序进行承诺，通过从应该在它之前完成的承诺的then返回后面的承诺。

把这样的一组 promise 想象成一棵树，其中的分支代表顺序进程，而叶子代表并发进程，这会很有帮助。

构建这样一棵 Promise 树的过程类似于构建其他类型树的非常常见的任务：维护指向当前在树中添加分支的位置的指针或引用，并迭代地添加内容。

正如@Esalija 在他的回答中指出的那样，如果您有一组不带参数的承诺返回函数，您可以使用reduce为您整齐地构建树。 如果您曾经为自己实现过 reduce，您就会明白在@Esilija 的回答中，reduce 在幕后所做的是维护对当前承诺 ( cur ) 的引用，并让每个承诺在其then返回下一个承诺。

如果你没有一个很好的同构数组（关于它们接受/返回的参数）承诺返回函数，或者如果你需要一个比简单线性序列更复杂的结构，你可以通过维护自己构建承诺树对承诺树中要添加新承诺的位置的引用：

var root_promise = current_promise = Ember.Deferred.create(); 
// you can also just use your first real promise as the root; the advantage of  
// using an empty one is in the case where the process of BUILDING your tree of 
// promises is also asynchronous and you need to make sure it is built first 
// before starting it

current_promise = current_promise.then(function(){
  return // ...something that returns a promise...;
});

current_promise = current_promise.then(function(){
  return // ...something that returns a promise...;
});

// etc.

root_promise.resolve();

您可以通过使用 RSVP.all 向承诺“分支”添加多个“叶子”来构建并发和顺序进程的组合。 我因过于复杂而被低估的答案显示了一个例子。

您还可以使用 Ember.run.scheduleOnce('afterRender') 来确保在一个承诺中完成的某些事情在下一个承诺被触发之前被渲染——我的反对票太复杂的答案也显示了一个例子。

Answer 5

另一种方法是在Promise原型上定义一个全局序列函数。

Promise.prototype.sequence = async (promiseFns) => {
  for (let promiseFn of promiseFns) {
    await promiseFn();
  }
}

然后你可以在任何地方使用它，就像Promise.all()

例子

const timeout = async ms => new Promise(resolve =>
  setTimeout(() => {
    console.log("done", ms);
    resolve();
  }, ms)
);

// Executed one after the other
await Promise.sequence([() => timeout(1000), () => timeout(500)]);
// done: 1000
// done: 500

// Executed in parallel
await Promise.all([timeout(1000), timeout(500)]);
// done: 500
// done: 1000

免责声明：小心编辑原型！

Answer 6

我有类似的问题，我做了一个递归函数，它一个一个依次运行函数。

var tasks = [fn1, fn2, fn3];

var executeSequentially = function(tasks) {
  if (tasks && tasks.length > 0) {
    var task = tasks.shift();

    return task().then(function() {
      return executeSequentially(tasks);
    });
  }

  return Promise.resolve();  
};

如果您需要从这些函数收集输出：

var tasks = [fn1, fn2, fn3];

var executeSequentially = function(tasks) {
  if (tasks && tasks.length > 0) {
    var task = tasks.shift();

    return task().then(function(output) {
      return executeSequentially(tasks).then(function(outputs) {
        outputs.push(output);

        return Promise.resolve(outputs);  
      });
    });
  }

  return Promise.resolve([]);
};

Answer 7

只需要解决一个for循环 :)

var promises = [a,b,c];
var chain;

for(let i in promises){
  if(chain) chain = chain.then(promises[i]);
  if(!chain) chain = promises[i]();
}

function a(){
  return new Promise((resolve)=>{
    setTimeout(function(){
      console.log('resolve A');
      resolve();
    },1000);
  });
}
function b(){
  return new Promise((resolve)=>{
    setTimeout(function(){
      console.log('resolve B');
      resolve();
    },500);
  });
}
function c(){
  return new Promise((resolve)=>{
    setTimeout(function(){
      console.log('resolve C');
      resolve();
    },100);
  });
}

Answer 8

export type PromiseFn = () => Promise<any>;

export class PromiseSequence {
  private fns: PromiseFn[] = [];

  push(fn: PromiseFn) {
    this.fns.push(fn)
  }

  async run() {
    for (const fn of this.fns) {
      await fn();
    }
  }
}

然后

const seq = new PromiseSequence();
seq.push(() => Promise.resolve(1));
seq.push(() => Promise.resolve(2));
seq.run();

也可以将承诺返回的内容存储在另一个私有变量中并将其传递给回调

Answer 9

我所追求的本质上是 mapSeries，我碰巧正在映射保存一组值，我想要结果。

所以，就我所知，这是为了帮助其他人在未来寻找类似的东西。

（请注意，上下文是 Ember 应用程序）。

App = Ember.Application.create();

App.Router.map(function () {
    // put your routes here
});

App.IndexRoute = Ember.Route.extend({
    model: function () {
            var block1 = Em.Object.create({save: function() {
                return Em.RSVP.resolve("hello");
            }});
    var block2 = Em.Object.create({save: function() {
            return Em.RSVP.resolve("this");
        }});
    var block3 = Em.Object.create({save: function() {
        return Em.RSVP.resolve("is in sequence");
    }});

    var values = [block1, block2, block3];

    // want to sequentially iterate over each, use reduce, build an array of results similarly to map...

    var x = values.reduce(function(memo, current) {
        var last;
        if(memo.length < 1) {
            last = current.save();
        } else {
            last = memo[memo.length - 1];
        }
        return memo.concat(last.then(function(results) {
            return current.save();
        }));
    }, []);

    return Ember.RSVP.all(x);
    }
});