Run functions that return promises in series after promise is done

Question

I have an array of functions that I need to execute. Those functions all return a promise.

I want to run all the functions in series, but the next function can only be started if the promise of the previous function is done.

I thought this would be easy with the async or bluebird library, but I can't find a simple solution to this.

Here is something I made (untested), but I was looking for a standard library solution because this probably already exists?

function runFuncs(funcs) {

    function funcRunner(funcs, resolve, reject, pos=0) {
        funcs[pos]().then(function() {
            pos++;
            if (pos < length(funcs)) {
                funcRunner(funcs, pos);
            } else {
                resolve();
            }
        }).catch(function(err) {
            reject(err);
        });
    }

    return new Promise(function(resolve, reject) {
        funcRunner(funcs, resolve, reject);
    });
}

Can you include `js` that you have tried at Question? And describe what expected and actual result are? — guest271314, May 06 '16 at 20:21
^^^^ need some code in order to help you. what @guest271314 said — Sitian Liu, May 06 '16 at 20:29
@r03 _"Here is something I made (untested), but I was looking for a standard library solution because this probably already exists?"_ Not certain what Question is? Are you seeking a recommendation for a library that uses a pattern similar to `js` at Question? Can you include `js` contained in `funcs` array at Question? — guest271314, May 06 '16 at 20:36
Potential answer here: http://stackoverflow.com/questions/24586110/resolve-promises-one-after-another-i-e-in-sequence — Tom, May 06 '16 at 20:37

Chris Tavares · Answer 1 · 2016-05-06T21:33:44.590

4

If each of the functions returns a promise itself, you can just chain them together. Something like this should work:

function runFuncs(funcs) {
  return funcs.reduce(function (p, funcToRun) {
      return p.then(function () {
        return funcToRun();
      });
  }, Promise.resolve(null));
}

Basically, you just keep chaining the promises together. By the nature of the chain, if you return a promise from the then handler, that becomes the resulting promise. So the reduce call goes through each promise in the array, doing a then on it to process the next one in the array.

edited May 06 '16 at 21:33

answered May 06 '16 at 20:55

Chris Tavares

29,165
4
46
63

This is a much better answer than mine. :) – lanceball May 06 '16 at 21:06

score 1 · Accepted Answer · edited May 08 '16 at 20:21

1

I know you've marked an answer already, but I can't comment yet and had to ask: Your example doesn't seem to pass results from one function to another, do you really need them to run in series?

If series is a hard requirement, Bluebird's .mapSeries() method will do exactly what you're looking for, and the code is incredibly neat. Otherwise you can swap in .map() and leverage concurrency to get things done in parallel.

Promise.mapSeries(fnArray, (fn) => 
{
    return fn(...);
})
.then((results) =>
{
    // do something with the results.
});

Or in parallel with .map():

Promise.map(fnArray, (fn) => 
{
    return fn(...);
}, 
{ concurrency: 5 })
.then((results) =>
{
    // do something with the results.
});

edited May 08 '16 at 20:21

roeland

6,058
7
50
67

answered May 07 '16 at 11:49

Paul Midgen

86
4

yes, the next function may only start when the promise of the previous is done (not just started). – roeland May 08 '16 at 14:07
thanks for the clarification. `.mapSeries` is a good option, if using a library is the way you want to go. – Paul Midgen May 08 '16 at 16:14

score 0 · Answer 3 · answered May 06 '16 at 21:02

Using no additional libraries, just plain old JS code, I was able to come up with a simple solution.

'use strict';

// Create an array of functions that return a promise
const promises = [];
let i = 0;
while (i++ < 10) {
  const v = i;
  promises.push(() => {
    return new Promise( (resolve, reject) => {
      setTimeout(() => {
        resolve(v);
      }, Math.floor(Math.random() * 1000));
    });
  });
}

function nextPromise(idx) {
  if (idx >= promises.length) return;
  promises[idx]().then((v) => {
    console.log("Resolved", v);
    nextPromise(++idx);
  });  
}

nextPromise(0);

In this example, I created an array of 10 functions, each of which returns a promise which resolves a monotonically increasing number after random number of milliseconds.

To execute them all sequentially, I just use some recursion. It's kind of an ugly bit of hackey looking code, but it works.

score 0 · Answer 4 · answered May 25 '17 at 16:03

0

If "funcs" is array of promises, you can to use Promise.all() - Promise docs

import {Promise} from 'es6-promise';

const runFuncs = funcs => {
  return Promise.all(funcs);
};

export default runFuncs;

answered May 25 '17 at 16:03

André Filipe Goulart

1

Run functions that return promises in series after promise is done

4 Answers4