Comment puis-je exécuter tableau de promesses dans l'ordre?

Si vous les avez déjà dans un tableau alors qu'ils sont déjà en cours d'exécution. Si vous avez une promesse alors qu'il est déjà en cours d'exécution. Ce n'est pas une préoccupation des promesses (I. E ils ne sont pas comme C# Tasks dans ce domaine .Start() méthode). .all ne pas exécuter quoi que ce soit
elle renvoie simplement une promesse.

Si vous avez un tableau de la promesse de revenir fonctions:

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

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

Ou valeurs:

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

ES7 voie en 2017.

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

Cela permettra d'exécuter les fonctions de manière séquentielle(un par un), et non pas en parallèle. Le paramètre promises est un tableau de fonctions, qui renvoient Promise.

Plunker exemple avec le code ci-dessus: http://plnkr.co/edit/UP0rhD?p=preview

Je vais laisser cette réponse ici, car ce serait m'ont aidé quand je suis venu ici à la recherche d'une solution à mon problème.

La chose que je recherchais était essentiellement mapSeries... et il m'arrive d'être de cartographie enregistrer sur un ensemble de valeurs... et je veux les résultats...

Donc, ici, est aussi loin que j'ai eu, FWIW, pour aider les autres à la recherche pour des choses similaires dans le futur....

(À noter que le contexte est une braise app)

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

J'ai eu le même problème, et j'ai fait une fonction récursive qui exécute les fonctions une par une de manière séquentielle.

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

Dans le cas où vous avez besoin de collecter de sortie de ces fonctions:

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([]);
};