I have a promise-returning function that does some async stuff, let's call it functionToRepeat().

I am trying to write the function repeatFunction(amount) , so that it will start the promise, wait for pletion, start it again, wait for pletion, and so on a given amount of times. This repeatFunction(amount) should also be thenable, so that I can chain other stuff after it's been executed.

Here is my attempt:

function functionToRepeat(){
  let action = new Promise(function(resolve,reject){
    setTimeout(function(){
      console.log("resolved!");
      resolve()}
    ,1000);
  })
  return action
}

function repeatFunction(amount) {
  if(amount==0){
    return Promise.resolve();
  }
  return functionToRepeat().then(function(){
    repeatFunction(amount-1);
  });
}

repeatFunction(5).then(function(){
 console.log("DONE!");
})

This successfully chains my promises (or so it seams, I get one "resolved!" per second in the console). However the .then() I try to chain after my repeatFunction(5) happens after the 1st promise ends, not after all 5 have ended!

So in my console I get:

resolved! DONE! resolved! resolved! resolved! resolved!

What am I doing wrong and what should I change?

I have a promise-returning function that does some async stuff, let's call it functionToRepeat().

I am trying to write the function repeatFunction(amount) , so that it will start the promise, wait for pletion, start it again, wait for pletion, and so on a given amount of times. This repeatFunction(amount) should also be thenable, so that I can chain other stuff after it's been executed.

Here is my attempt:

function functionToRepeat(){
  let action = new Promise(function(resolve,reject){
    setTimeout(function(){
      console.log("resolved!");
      resolve()}
    ,1000);
  })
  return action
}

function repeatFunction(amount) {
  if(amount==0){
    return Promise.resolve();
  }
  return functionToRepeat().then(function(){
    repeatFunction(amount-1);
  });
}

repeatFunction(5).then(function(){
 console.log("DONE!");
})

This successfully chains my promises (or so it seams, I get one "resolved!" per second in the console). However the .then() I try to chain after my repeatFunction(5) happens after the 1st promise ends, not after all 5 have ended!

So in my console I get:

resolved! DONE! resolved! resolved! resolved! resolved!

What am I doing wrong and what should I change?

• javascript
• promise
• es6-promise

8 Answers 8

I think you are almost there, but you have to return the repeatFunction again in the then block of your function to repeat.

return functionToRepeat().then(function(){
    return repeatFunction(amount-1);
  });
}

If you have a then, but do not return anything, then it will just resolve the upper promise. That is what happened.

How about simply:

function repeat(func, times) {
  var promise = Promise.resolve();
  while (times-- > 0) promise = promise.then(func);
  return promise;
}

When tested with this:

function oneSecond() {
  return new Promise(function (resolve, reject) {
    setTimeout(function () {
      console.log("tick");
      resolve();
    }, 1000);
  });
}

repeat(oneSecond, 5).then(function () {
    console.log("done");
});

this output is produced over 5 seconds:

tick
tick
tick
tick
tick
done

You're missing a return when you call repeatFunction(amount-1)

function functionToRepeat(){
  let action = new Promise(function(resolve,reject){
    setTimeout(function(){
      console.log("resolved!");
      resolve()}
    ,1000);
  })
  return action
}

function repeatFunction(amount) {
  if(amount==0){
    return Promise.resolve();
  }
  return functionToRepeat().then(function(){
    return repeatFunction(amount-1); // Added return
  });
}

repeatFunction(5).then(function(){
 console.log("DONE!");
})

https://plnkr.co/edit/93T6B4QkBv0mYS4xPw0a?p=preview

You could use async/await with a simple while loop. This keeps you in Asyncland allows you to continue chaining after the repeated function is done

async function asyncRepeat (f, n) {
  while (n-- > 0)
    await f()
}

asyncRepeat(functionToRepeat, 5).then(() => {
  console.log('done')
})

// some value
// some value
// some value
// some value
// some value
// done

This is trash tho. You're restricted to using a side-effecting function as your f argument to asyncRepeat. So logging to the console works, but what if you actually wanted to do something with that value?

Here's an update to asyncRepeat that allows you to thread a value thru the repeated application of your input function (asyncDouble in this example)

(important changes in bold)

async function asyncRepeat (f, n, x) {
  while (n-- > 0)
    x = await f(x)
  return x
}

function asyncDouble (x) {
  return new Promise(function (resolve, reject) {
    setTimeout(() => {
      console.log('x is currently: %d', x)
      resolve(x * 2) // resolve an actual value
    }, 1000)
  })
}

asyncRepeat(asyncDouble, 5, 2).then(result => {
  console.log('result: %d', result)
})

// x is currently: 2
// x is currently: 4
// x is currently: 8
// x is currently: 16
// x is currently: 32
// result: 64

I wanted something similar, so I wrote a generic function at (https://repl.it/@turlockmike/BriskLovableLinuxkernel)

function repeat(fn, times) {
  if (times == 1) {
    return fn()
  } else {
    return new Promise(function(resolve, reject) {
      return fn().then(function() {
        return resolve(repeat(fn,times - 1))
      })
    })
  }
}

Usage

function doSomething() {
  return new Promise(function(resolve, reject) {
     //do something interested here
     setTimeout(function(){
       console.log("resolved!");
       resolve()}
     ,1000);
  })
}

repeat(doSomething, 5).then(() => {
  console.log("all Done!")
}) 

const http = require('http');
const https = require('https');
const { t, d, r } = require('minimist')(process.argv.slice(2));

const checkRoot = config => {
  const { delaySeconds, rootUrl } = config ? config : { delaySeconds: 6 };
  const delay = delaySeconds * 1000;
  const protocolString = rootUrl.split(':')[0];
  const protocol = {
    http: http,
    https: https,
  };
  return new Promise(res => {
    setTimeout(() => {
      protocol[protocolString]
        .get(rootUrl, resp => {
          let data = '';
          resp.on('data', chunk => {
            data += chunk;
          });
          resp.on('end', () => {
            res({ success: data.includes('<!doctype html>') });
          });
        })
        .on('error', err => {
          console.log(`Error: ${err.message}`);
          res({ success: false });
        });
    }, delay);
  });
};
const repeatChecking = async ({ times, delaySeconds, rootUrl }) => {
  let isReady = false;
  console.log(
    `will try ${times}, and with ${delaySeconds} seconds delay in between for ${rootUrl}`
  );
  let i = 1;
  while (i <= times) {
    if (isReady === true) {
      break;
    }
    const res = await checkRoot({ delaySeconds, rootUrl }).then();
    isReady = res.success;
    console.log(`testing ${i}, status: root ready => ${res.success}`);
    i++;
  }
  if (isReady) {
    console.log('Done, root is ready');
    return;
  }
  process.stdout.write('ERROR: root could not be reached\n');
  process.exit(1);
};

repeatChecking({ times: t, delaySeconds: d, rootUrl: r });

let loopP = (n, f, ...args) => {
  let p = f(...args);
  p.then(res => {
    if (n - 1) {
      loopP(n - 1, f, res);
    }
  });
};

Where n is the number of iterations, f is the Promise-returning function to be called. Each successive call to f is passed the results of the previous call when it resolves.

For instance...

let addOneP = i => {
  console.log(i + 1);
  return Promise.resolve(i + 1);
};

loopP(5, addOneP, 0);
// logs:
// 1
// 2
// 3
// 4
// 5

You might find relign useful for this kind of thing. Here's your example written with relign series and relign setTimeout.

const fnToRepeat = () =>
  relign.setTimeout(() => console.log("resolved!"), 1000);

relign.series((new Array(5)).fill(fnToRepeat))
  .then(() => console.log('done'));