Resolve promises one after another i e in sequence

Question

Consider the following code that reads an array of files in a serial sequential manner  readFiles returns a promise  which is resolved only once all files have been read in sequence  var readFile   function file             Returns a promise      var readFiles   function files      return new Promise  resolve  reject    gt        var readSequential   function index          if  index  gt   files length            resolve            else           readFile files index   then function               readSequential index   1              catch reject                       readSequential 0      Start with the first file            The above code works  but I don t like having to do recursion for things to occur sequentially  Is there a simpler way that this code can be re-written so that I don t have to use my weird readSequential function  Originally I tried to use Promise all  but that caused all of the readFile calls to happen concurrently  which is not what I want  var readFiles   function files      return Promise all files map function file        return readFile file

User · Answer

You can use this function that gets promiseFactories List:

function executeSequentially(promiseFactories) {
    var result = Promise.resolve();
    promiseFactories.forEach(function (promiseFactory) {
        result = result.then(promiseFactory);
    });
    return result;
}

Promise Factory is just simple function that returns a Promise:

function myPromiseFactory() {
    return somethingThatCreatesAPromise();
}

It works because a promise factory doesn't create the promise until it's asked to. It works the same way as a then function – in fact, it's the same thing!

You don't want to operate over an array of promises at all. Per the Promise spec, as soon as a promise is created, it begins executing. So what you really want is an array of promise factories...

If you want to learn more on Promises, you should check this link: https://pouchdb.com/2015/05/18/we-have-a-problem-with-promises.html

User · Answer

My answer based on https   stackoverflow com a 31070150 7542429   Promise series   function series arrayOfPromises        var results           return arrayOfPromises reduce function seriesPromise  promise          return seriesPromise then function             return promise          then function result              results push result                                Promise resolve         then function           return results                 This solution returns the results as an array like Promise all     Usage   Promise series  array of promises    then function results          do stuff with results here

User · Answer

Most of the answers dont include the results of ALL promises individually  so in case someone is looking for this particular behaviour  this is a possible solution using recursion   It follows the style of Promise all    Returns the array of results in the  then   callback  If some promise fails  its returned immediately in the  catch   callback     x000D   x000D  const promiseEach    arrayOfTasks    gt    x000D    let results      x000D    return new Promise  resolve  reject    gt    x000D      const resolveNext    arrayOfTasks    gt    x000D           If all tasks are already resolved  return the final array of results x000D        if  arrayOfTasks length     0  return resolve results  x000D   x000D           Extract first promise and solve it x000D        const first   arrayOfTasks shift   x000D   x000D        first   then  res    gt    x000D          results push res  x000D          resolveNext arrayOfTasks  x000D           catch  err    gt    x000D          reject err  x000D           x000D        x000D      resolveNext arrayOfTasks  x000D       x000D    x000D   x000D     Lets try it  x000D   x000D  const promise    time  shouldThrowError    gt  new Promise  resolve  reject    gt    x000D    const timeInMs   time   1000 x000D    setTimeout     gt   x000D      console log  Waited   time  secs   x000D      if  shouldThrowError  reject new Error  Promise failed    x000D      resolve time  x000D       timeInMs  x000D     x000D   x000D  const tasks         gt  promise 1        gt  promise 2   x000D   x000D  promiseEach tasks  x000D     then  res    gt    x000D      console log res      1  2  x000D       x000D       Oops some promise failed x000D     catch  error    gt    x000D      console log error  x000D       x000D   x000D   x000D    Note about the tasks array declaration   In this case is not possible to use the following notation like Promise all would use   const tasks    promise 1   promise 2     And we have to use   const tasks         gt  promise 1        gt  promise 2     The reason is that JavaScript starts executing the promise immediatelly after its declared  If we use methods like Promise all  it just checks that the state of all of them is fulfilled or rejected  but doesnt start the exection itself  Using      gt  promise   we stop the execution until its called

User · Answer

This question is old  but we live in a world of ES6 and functional JavaScript  so let s see how we can improve   Because promises execute immediately  we can t just create an array of promises  they would all fire off in parallel   Instead  we need to create an array of functions that returns a promise  Each function will then be executed sequentially  which then starts the promise inside   We can solve this a few ways  but my favorite way is to use reduce   It gets a little tricky using reduce in combination with promises  so I have broken down the one liner into some smaller digestible bites below   The essence of this function is to use reduce starting with an initial value of Promise resolve      or a promise containing an empty array   This promise will then be passed into the reduce method as promise  This is the key to chaining each promise together sequentially  The next promise to execute is func and when the then fires  the results are concatenated and that promise is then returned  executing the reduce cycle with the next promise function   Once all promises have executed  the returned promise will contain an array of all the results of each promise   ES6 Example  one liner         serial executes Promises sequentially      param  funcs  An array of funcs that return promises      example    const urls      url1     url2     url3      serial urls map url   gt       gt    ajax url            then console log bind console       const serial   funcs   gt      funcs reduce  promise  func    gt          promise then result   gt  func   then Array prototype concat bind result     Promise resolve        ES6 Example  broken down      broken down to for easier understanding  const concat   list   gt  Array prototype concat bind list  const promiseConcat   f   gt  x   gt  f   then concat x   const promiseReduce    acc  x    gt  acc then promiseConcat x         serial executes Promises sequentially      param  funcs  An array of funcs that return promises      example    const urls      url1     url2     url3      serial urls map url   gt       gt    ajax url            then console log bind console       const serial   funcs   gt  funcs reduce promiseReduce  Promise resolve        Usage      first take your work const urls      url1     url2     url3     url4       next convert each item to a function that returns a promise const funcs   urls map url   gt       gt    ajax url       execute them serially serial funcs       then console log bind console

User · Answer

Use Array prototype reduce  and remember to wrap your promises in a function otherwise they will already be running      array of Promise providers  const providers       function         return Promise resolve 1          function         return Promise resolve 2          function         return Promise resolve 3           const inSeries   function providers      const seed   Promise resolve null       return providers reduce function a b         return a then b        seed        nice and easy    you should be able to re-use the same seed for performance  etc   It s important to guard against empty arrays or arrays with only 1 element when using reduce  so this technique is your best bet      const providers           function v            return Promise resolve v 1                  function v            return Promise resolve v 2                  function v            return Promise resolve v 3                      const inSeries   function providers  initialVal            if providers length  lt  1               return Promise resolve null                     return providers reduce  a b    gt  a then b   providers shift   initialVal             and then call it like   inSeries providers  1  then v   gt       console log v       7

User · Answer

I use the following code to extend the Promise object  It handles rejection of the promises and returns an array of results   Code         Runs tasks in sequence and resolves a promise upon finish      tasks  an array of functions that return a promise upon call      parameters  an array of arrays corresponding to the parameters to be passed on each function call      context  Object to use as context to call each function   The  this  keyword that may be used inside the function definition     Promise sequence   function tasks  parameters       context   null        return new Promise  resolve  reject   gt            var nextTask   tasks splice 0 1  0  apply context  parameters 0      Dequeue and call the first task         var output   new Array tasks length   1           var errorFlag   false           tasks forEach  task  index    gt                nextTask   nextTask then r   gt                    output index    r                  return task apply context  parameters index 1                   e  gt                   output index    e                  errorFlag   true                  return task apply context  parameters index 1                                            Last task         nextTask then r  gt               output output length - 1    r              if  errorFlag  reject output   else resolve output                       catch e  gt               output output length - 1    e              reject output                            Example  function functionThatReturnsAPromise n        return new Promise  resolve  reject   gt             Emulating real life delays  like a web request         setTimeout     gt               resolve n              1000              var arrayOfArguments      a     b     c     d     var arrayOfFunctions    new Array 4   fill functionThatReturnsAPromise     Promise sequence arrayOfFunctions  arrayOfArguments   then console log   catch console error

User · Answer

To do this simply in ES6   function files         Create a new empty promise  don t do that with real people      var sequence   Promise resolve          Loop over each file  and add on a promise to the      end of the  sequence  promise    files forEach file   gt            Chain one computation onto the sequence     sequence          sequence          then      gt  performComputation file            then result   gt  doSomething result                Resolves for each file  one at a time              This will resolve after the entire chain is resolved   return sequence

User · Answer

If someone else needs a guaranteed way of STRICTLY sequential way of resolving Promises when performing CRUD operations you also can use the following code as a basis   As long as you add  return  before calling each function  describing a Promise  and use this example as a basis the next  then   function call will CONSISTENTLY start after the completion of the previous one   getRidOfOlderShoutsPromise        gt        return readShoutsPromise  BEFORE        then      gt            return deleteOlderShoutsPromise                then      gt            return readShoutsPromise  AFTER               catch err   gt  console log err message       deleteOlderShoutsPromise        gt        return new Promise    resolve  reject    gt            console log  in deleteOlderShouts            let d   new Date            let TwoMinuteAgo   d - 1000   90           All Shouts deleteMany   dateTime    lt  TwoMinuteAgo    function err                if  err  reject                console log  DELETED OLDs at   d               resolve                                   readShoutsPromise    tex    gt        return new Promise   resolve  reject    gt            console log  in readShoutsPromise -  tex           All Shouts          find              sort    dateTime    ascending              exec function  err  data               if  err  reject                let d   new Date                console log  shouts   tex   delete PROMISE     data length     date    d               resolve data

User · Answer

This is to extend on how to process a sequence of promises in a more generic way  supporting dynamic   infinite sequences  based on spex sequence implementation   var  q   require  q    var spex   require  spex    q    var files          any dynamic source of files   var readFile   function  file           returns a promise      function source index        if  index  lt  files length            return readFile files index             function dest index  data           data   resolved data from readFile     spex sequence source  dest       then function  data               finished the sequence              catch function  error               error            Not only this solution will work with sequences of any size  but you can easily add data throttling and load balancing to it

User · Answer

This is a slight variation of another answer above   Using native Promises   function inSequence tasks        return tasks reduce  p  task    gt  p then task   Promise resolve        Explanation  If you have these tasks  t1  t2  t3   then the above is equivalent to Promise resolve   then t1  then t2  then t3    It s the behavior of reduce   How to use  First You need to construct a list of tasks   A task is a function that accepts no argument   If you need to pass arguments to your function  then use bind or other methods to create a task   For example   var tasks   files map file   gt  processFile bind null  file   inSequence tasks  then

User · Answer

Using modern ES    const series   async  tasks    gt      const results          for  const task of tasks        const result   await task       results push result          return results             const readFiles   await series files map readFile

User · Answer

I created this simple method on the Promise object   Create and add a Promise sequence method to the Promise object  Promise sequence   function  chain        var results           var entries   chain      if  entries entries  entries   entries entries        return new Promise function  yes  no            var next   function                  var entry   entries next                if entry done  yes results               else                   results push entry value 1    then next  function     no results                                          next                 Usage   var todo        todo push firstPromise   if  someCriterium  todo push optionalPromise   todo push lastPromise       Invoking them Promise sequence todo       then function results      function results         The best thing about this extension to the Promise object  is that it is consistent with the style of promises  Promise all and Promise sequence is invoked the same way  but have different semantics   Caution  Sequential running of promises is not usually a very good way to use promises  It s usually better to use Promise all  and let the browser run the code as fast as possible  However  there are real use cases for it - for example when writing a mobile app using javascript

User · Answer

I ve had to run a lot of sequential tasks and used these answers to forge a function that would take care of handling any sequential task     function one by one objects array  iterator  callback        var start promise   objects array reduce function  prom  object            return prom then function                  return iterator object                      Promise resolve        initial     if callback           start promise then callback        else          return start promise            The function takes 2 arguments   1 optional  First argument is the array on which we will be working  The second argument is the task itself  a function that returns a promise  the next task will be started only when this promise resolves  The third argument is a callback to run when all tasks have been done  If no callback is passed  then the function returns the promise it created so we can handle the end   Here s an example of usage   var filenames     1 jpg   2 jpg   3 jpg    var resize task   function filename         return promise of async resizing with filename    one by one filenames resize task      Hope it saves someone some time

User · Answer

function       function sleep ms        return new Promise function resolve          setTimeout function             return resolve             ms                  function serial arr  index  results        if  index    arr length          return Promise resolve results             return new Promise function resolve  reject          if   index            index   0          results                     return arr index             then function d              return resolve d                       catch function err              return reject err                             then function result            console log  here            results push result           return serial arr  index   1  results                   catch function err            throw err                   const a    5000  5000  5000      serial a map x   gt       gt  sleep x             Here the key is how you call the sleep function  You need to pass an array of functions which itself returns a promise instead of an array of promises

User · Answer

Update 2017  I would use an async function if the environment supports it   async function readFiles files      for const file of files        await readFile file            If you d like  you can defer reading the files until you need them using an async generator  if your environment supports it    async function  readFiles files      for const file of files        yield await readFile file              Update  In second thought - I might use a for loop instead   var readFiles   function files      var p   Promise resolve       Q   in q    files forEach file   gt        p   p then      gt  readFile file            return p       Or more compactly  with reduce   var readFiles   function files      return files reduce  p  file    gt         return p then      gt  readFile file         Promise resolve        initial      In other promise libraries  like when and Bluebird  you have utility methods for this   For example  Bluebird would be   var Promise   require  bluebird    var fs   Promise promisifyAll require  fs      var readAll   Promise resolve files  map fs readFileAsync  concurrency  1        if the order matters  you can use Promise each instead and omit concurrency param  readAll then function allFileContents          do stuff to read files        Although there is really no reason not to use async await today

User · Answer

Here is how I prefer to run tasks in series    function runSerial         var that   this         task1 is a function that returns a promise  and immediately starts executing         task2 is a function that returns a promise  and immediately starts executing      return Promise resolve            then function                 return that task1                        then function                 return that task2                        then function                 console log   ---- done ----                         What about cases with more tasks  Like  10    function runSerial tasks      var result   Promise resolve      tasks forEach task   gt        result   result then      gt  task             return result

User · Answer

I really liked  joelnet s answer  but to me  that style of coding is a little bit tough to digest  so I spent a couple of days trying to figure out how I would express the same solution in a more readable manner and this is my take  just with a different syntax and some comments      first take your work const urls      url1     url2     url3     url4       next convert each item to a function that returns a promise const functions   urls map  url    gt         For every url we return a new function   return      gt        return new Promise  resolve    gt             random wait in milliseconds       const randomWait   parseInt  Math random     1000  10        console log  waiting to resolve in ms   randomWait        setTimeout     gt resolve  randomWait  url   randomWait                  const promiseReduce    acc  next    gt         we wait for the accumulator to resolve it s promise   return acc then  accResult    gt           and then we return a new promise that will become        the new value for the accumulator     return next   then  nextResult    gt             that eventually will resolve to a new array containing          the value of the two promises       return accResult concat nextResult                    the accumulator will always be a promise that resolves to an array const accumulator   Promise resolve         we call reduce with the reduce function and the accumulator initial value functions reduce promiseReduce  accumulator     then  result    gt           let s display the final value here     console log      The final result           console log result

User · Answer

As Bergi noticed  I think the best and clear solution is use BlueBird each  code below   const BlueBird   require  bluebird    BlueBird each files  fs readFileAsync

User · Answer

Nicest solution that I was able to figure out was with bluebird promises  You can just do Promise resolve files  each fs readFileAsync   which guarantees that promises are resolved sequentially in order

User · Answer

With async await of ES2016  and maybe some features of ES2018   this can be reduced to this form  function readFile file             Returns a promise     async function readFiles files      for  file in files         await readFile file         I haven t seen another answer express that simplicity  The OP said parallel execution of readFile was not desired  However  with IO like this it really makes sense to not be blocking on a single file read  while keeping the loop execution synchronous  you don t want to do the next step until all files have been read   Since I just learned about this and am a bit excited about it  I ll share that approach of parallel asynchronous execution of readFile with overall synchronous execution of readFiles  async function readFiles files      await Promise all files map readFile      Isn t that a thing of beauty

User · Answer

On the basis of the question s title   Resolve promises one after another  i e  in sequence     we might understand that the OP is more interested in the sequential handling of promises on settlement than sequential calls per se    This answer is offered     to demonstrate that sequential calls are not necessary for sequential handling of responses  to expose viable alternative patterns to this page s visitors - including the OP if he is still interested over a year later  despite the OP s assertion that he does not want to make calls concurrently  which may genuinely be the case but equally may be an assumption based on the desire for sequential handling of responses as the title implies    If concurrent calls are genuinely not wanted then see Benjamin Gruenbaum s answer which covers sequential calls  etc  comprehensively   If however  you are interested  for improved performance  in patterns which allow concurrent calls followed by sequential handling of responses  then please read on    It s tempting to think you have to use Promise all arr map fn   then fn   as I have done many times  or a Promise lib s fancy sugar  notably Bluebird s   however  with credit to this article  an arr map fn  reduce fn  pattern will do the job  with the advantages that it     works with any promise lib - even pre-compliant versions of jQuery - only  then   is used  affords the flexibility to skip-over-error or stop-on-error  whichever you want with a one line mod    Here it is  written for Q   var readFiles   function files        return files map readFile    Make calls in parallel       reduce function sequence  filePromise            return sequence then function                 return filePromise             then function file                  Do stuff with file     in the correct sequence             function error                console log error     optional             return sequence   skip-over-error  To stop-on-error   return error   jQuery   or  throw  error   Promises A                       Q    then function                all done               Note  only that one fragment  Q    is specific to Q  For jQuery you need to ensure that readFile   returns a jQuery promise  With A  libs  foreign promises will be assimilated   The key here is the reduction s sequence promise  which sequences the handling of the readFile promises but not their creation   And once you have absorbed that  it s maybe slightly mind-blowing when you realise that the  map   stage isn t actually necessary  The whole job  parallel calls plus serial handling in the correct order  can be achieved with reduce   alone  plus the added advantage of further flexibility to     convert from parallel async calls to serial async calls by simply moving one line - potentially useful during development    Here it is  for Q again   var readFiles   function files        return files reduce function sequence  f            var filePromise   readFile f    Make calls in parallel  To call sequentially  move this line down one          return sequence then function                 return filePromise             then function file                  Do stuff with file     in the correct sequence             function error                console log error     optional             return sequence   Skip over any errors  To stop-on-error   return error   jQuery   or  throw  error   Promises A                       Q    then function                all done               That s the basic pattern  If you wanted also to deliver data  eg the files or some transform of them  to the caller  you would need a mild variant

User · Answer

Simple util for standard Node js promise   function sequence tasks  fn        return tasks reduce  promise  task    gt  promise then      gt  fn task    Promise resolve         UPDATE  items-promise is a ready to use NPM package doing the same

User · Answer

My preferred solution   function processArray arr  fn        return arr reduce           p  v    gt  p then  a    gt  fn v  then r   gt  a concat  r              Promise resolve                It s not fundamentally different from others published here but    Applies the function to items in series Resolves to an array of results Doesn t require async await  support is still quite limited  circa 2017  Uses arrow functions  nice and concise   Example usage   const numbers    0  4  20  100   const multiplyBy3    x    gt  new Promise res   gt  res x   3        Prints   0  12  60  300   processArray numbers  multiplyBy3  then console log     Tested on reasonable current Chrome  v59  and NodeJS  v8 1 2

User · Answer

First  you need to understand that a promise is executed at the time of creation  So for example if you have a code     a   b   c   map x   gt  returnsPromise x     You need to change it to     a   b   c   map x   gt       gt  returnsPromise x     Then we need to sequentially chain promises     a    b    c   map x   gt       gt  returnsPromise x        reduce           before  after    gt  before then     gt  after             Promise resolve           executing after    will make sure that promise is created  and executed  only when its time comes

User · Answer

Your approach is not bad  but it does have two issues  it swallows errors and it employs the Explicit Promise Construction Antipattern   You can solve both of these issues  and make the code cleaner  while still employing the same general strategy   var Q   require  q     var readFile   function file             Returns a promise      var readFiles   function files      var readSequential   function index        if  index  lt  files length          return readFile files index   then function             return readSequential index   1                              using Promise resolve   here in case files length is 0   return Promise resolve readSequential 0       Start

User · Answer

If you want you can use reduce to make a sequential promise  for example    2 3 4 5 6 7 8 9  reduce  promises  page    gt        return promises then  page    gt            console log page           return Promise resolve page 1                Promise resolve 1      it ll always works in sequential

User · Answer

With Async Await  if you have the support of ES7   function downloadFile fileUrl             This function return a Promise  async function main       var filesList             for  const file of filesList        await downloadFile file            you must use for loop  and not forEach because async await has problems running in forEach loop   Without Async Await  using Promise   function downloadFile fileUrl             This function return a Promise  function downloadRecursion filesList  index      index   index    0    if  index  lt  filesList length          downloadFile filesList index   then function               index          downloadRecursion filesList  index      self invocation - recursion                else         return Promise resolve           function main       var filesList            downloadRecursion filesList

User · Answer

Array push and pop method can be used for sequence of promises  You can also push new promises when you need additional data  This is the code  I will  use in React Infinite loader to load sequence of pages    x000D   x000D  var promises    Promise resolve     x000D   x000D  function methodThatReturnsAPromise page    x000D   return new Promise  resolve  reject    gt    x000D    setTimeout      gt    x000D     console log  Resolve-  page     new Date        x000D     resolve    x000D       1000   x000D       x000D    x000D   x000D  function pushPromise page    x000D   promises push promises pop   then function      x000D    return methodThatReturnsAPromise page  x000D        x000D    x000D   x000D  pushPromise 1   x000D  pushPromise 2   x000D  pushPromise 3   x000D   x000D   x000D

User · Answer

There s promise-sequence in nodejs  const promiseSequence   require  promise-sequence    return promiseSequence arr map el   gt       gt  doPromise el

[javascript] Resolve promises one after another (i.e. in sequence)?

Examples related to javascript

Examples related to promise

Examples related to q

Examples related to sequential

Examples related to serial-processing