Promise of a repeating sequence of serial calls

Question

Promise of a repeating sequence of serial calls

I am looking to create a recursive serial call to the promise method times, which will return the result of calling the fn function N times and storing the results in an array.

To achieve this, I have added a new attribute called results to the times function to store the output of each invocation of fn.

I want to avoid using module-scoped variables or passing extra parameters like times(fn, n, results) as it would alter the function signature.

Furthermore, I need to find a solution that restricts the use of async/await syntax.

Is there a way to utilize only function-local variables to store the results?

const times = Object.assign(
  (fn: (...args: any) => Promise<any>, n: number = 1) => {
    if (n === 0) return times.results;
    return fn().then((res) => {
      times.results.push(res);
      return times(fn, --n);
    });
  },
  { results: [] as any[] },
);

Usage:

const createPromise = (args: any) =>
  new Promise((resolve) => {
    setTimeout(() => {
      console.log(`[${new Date().toISOString()}]args: `, args);
      resolve(args);
    }, 1000);
  });

async function test() {
  const actual = await times(() => asyncFn('data'), 3);
  console.log(actual);  // output: [ 'data', 'data', 'data' ]
}

javascript typescript promise

Answer 1

Answer №1

Instead of using a stateful result variable, consider reversing the recursion direction:

function times<T>(fn: () => Promise<T>, n: number = 1): Promise<T[]> {
  if (n === 0) return Promise.resolve([]);
  else return times(fn, n-1).then(results =>
    fn().then(res => {
      results.push(res);
      return results;
    })
  });
}

If you prefer creating promises gradually, you can utilize an accumulator parameter like this:

function times<T>(fn: () => Promise<T>, n: number = 1, results: T[] = []): Promise<T[]> {
  if (n === 0) return Promise.resolve(results);
  else return fn().then(res => {
    results.push(res);
    return times(fn, n-1, results);
  });
}

To avoid adding an optional parameter to your function signature, you can use a local helper function for recursion:

function times<T>(fn: () => Promise<T>, n: number = 1): Promise<T[]> {
  function recurse(n: number, results: T[]): Promise<T[]> {
    if (n === 0) return Promise.resolve(results);
    else return fn().then(res => {
      results.push(res);
      return recurse(n-1, results);
    });
  }
  return recurse(n, []);
}
// Alternatively, in a more complex and stateful manner:
function times<T>(fn: () => Promise<T>, n: number = 1): Promise<T[]> {
  let results: T[] = [];
  function recurse(): Promise<T[]> {
    if (n-- === 0) return Promise.resolve(results);
    else return fn().then(res => {
      results.push(res);
      return recurse();
    });
  }
  return recurse();
}

Answer 2

Instead of using a stateful result variable, consider reversing the recursion direction:

function times<T>(fn: () => Promise<T>, n: number = 1): Promise<T[]> {
  if (n === 0) return Promise.resolve([]);
  else return times(fn, n-1).then(results =>
    fn().then(res => {
      results.push(res);
      return results;
    })
  });
}

If you prefer creating promises gradually, you can utilize an accumulator parameter like this:

function times<T>(fn: () => Promise<T>, n: number = 1, results: T[] = []): Promise<T[]> {
  if (n === 0) return Promise.resolve(results);
  else return fn().then(res => {
    results.push(res);
    return times(fn, n-1, results);
  });
}

To avoid adding an optional parameter to your function signature, you can use a local helper function for recursion:

function times<T>(fn: () => Promise<T>, n: number = 1): Promise<T[]> {
  function recurse(n: number, results: T[]): Promise<T[]> {
    if (n === 0) return Promise.resolve(results);
    else return fn().then(res => {
      results.push(res);
      return recurse(n-1, results);
    });
  }
  return recurse(n, []);
}
// Alternatively, in a more complex and stateful manner:
function times<T>(fn: () => Promise<T>, n: number = 1): Promise<T[]> {
  let results: T[] = [];
  function recurse(): Promise<T[]> {
    if (n-- === 0) return Promise.resolve(results);
    else return fn().then(res => {
      results.push(res);
      return recurse();
    });
  }
  return recurse();
}

Answer 3

Answer №2

If your goal is to create a sequential and recursive pattern, you can achieve it by following these steps:

Unique Solution:

Start by creating two promises in your function:
- finalPromise: This will be the promise returned from the function.
- promise: A promise that will be created by the passed fn.
For finalPromise, make sure to copy the reference of the resolver function and store it for manual invocation, labeled as resolverFn.
Create a variable named result to hold values. It should be of type any[].
When promise.then is called:
- Add the received value to the result array.
- Make a subsequent call to the function.
A trick for subsequent calls:
- If n === 1, the callback passed to times should be resolverFn. Ensure to bind result before passing or use () => resolverFn(result).
- Otherwise, pass fn.
Save the output of this call as innerPromise and when it resolves, invoke resolverFn with the result array.

Answer 4

If your goal is to create a sequential and recursive pattern, you can achieve it by following these steps:

Unique Solution:

Start by creating two promises in your function:
- finalPromise: This will be the promise returned from the function.
- promise: A promise that will be created by the passed fn.
For finalPromise, make sure to copy the reference of the resolver function and store it for manual invocation, labeled as resolverFn.
Create a variable named result to hold values. It should be of type any[].
When promise.then is called:
- Add the received value to the result array.
- Make a subsequent call to the function.
A trick for subsequent calls:
- If n === 1, the callback passed to times should be resolverFn. Ensure to bind result before passing or use () => resolverFn(result).
- Otherwise, pass fn.
Save the output of this call as innerPromise and when it resolves, invoke resolverFn with the result array.

Promise of a repeating sequence of serial calls

Answer №1

Answer №2

Unique Solution:

Similar questions

Angular Observable returning null results

Ways to expand the inheritance of a family's assets in the next generation

Having issues with my JavaScript timer - seeking assistance in troubleshooting the problem

Transforming Poloniex API Callback JSON into a compatible format for Highcharts.Stockchart

emphasize area when file is being uploaded

Steps for adding a sound effect, such as a button click noise, when clicking on a div tag

Troubleshooting issues with JavaScript progress bar functionality

What is the method for obtaining the value of a React-Select option?

Leveraging partials on their own

Problem with UV mapping when adjusting texture size

Integrating new components into JSON data

What is the best way to convert JavaScript to JSON in Python programming?

transferring iterative information via ajax data flow

Seeking out a particular key within a JSON object and then finding a match based on the id within that key's array - how can it be

Change the dropdown header behavior from hovering over it to clicking on it

Display previous 2 weeks (using vue.js)

Using JQuery to emphasize selected radio button area

Bring in a function by its name from the ts-nameof package that is not declared in the d.ts export

Retrieve data from an ASP.NET Web API endpoint utilizing AngularJS for seamless file extraction

Distinguishing which async HTTP GET response is providing data within a callback in Node.JS