Call Async/Await Functions in Parallel

Call async/await functions in parallel

When working with JavaScript, there may be situations where you need to call multiple async/await functions in parallel. This can be useful when you have independent tasks that can be executed concurrently, improving the overall performance of your application.

There are a few different approaches you can take to achieve this. Let’s explore two common solutions:

1. Using Promise.all()

The Promise.all() method takes an array of promises and returns a single promise that resolves when all of the input promises have resolved or rejects if any of the input promises reject. This makes it a great choice for calling async/await functions in parallel.

Here’s an example:

async function fetchData(url) {
  const response = await fetch(url);
  return response.json();
}

async function fetchMultipleData() {
  const urls = ['https://api.example.com/data1', 'https://api.example.com/data2', 'https://api.example.com/data3'];
  
  const promises = urls.map(url => fetchData(url));
  
  const results = await Promise.all(promises);
  
  return results;
}

fetchMultipleData()
  .then(data => {
    console.log(data);
  })
  .catch(error => {
    console.error(error);
  });

In this example, the fetchData() function is an async function that fetches data from a given URL. The fetchMultipleData() function calls fetchData() for each URL in parallel using map() to create an array of promises. Then, Promise.all() is used to wait for all promises to resolve, and the results are returned.

2. Using Promise.allSettled()

If you need to handle both resolved and rejected promises, you can use the Promise.allSettled() method. Unlike Promise.all(), Promise.allSettled() waits for all promises to settle (either resolve or reject) before returning the results.

Here’s an example:

async function fetchData(url) {
  const response = await fetch(url);
  return response.json();
}

async function fetchMultipleData() {
  const urls = ['https://api.example.com/data1', 'https://api.example.com/data2', 'https://api.example.com/data3'];
  
  const promises = urls.map(url => fetchData(url));
  
  const results = await Promise.allSettled(promises);
  
  return results;
}

fetchMultipleData()
  .then(data => {
    console.log(data);
  })
  .catch(error => {
    console.error(error);
  });

In this example, the fetchData() function is the same as before. The fetchMultipleData() function calls fetchData() for each URL in parallel using map() to create an array of promises. Then, Promise.allSettled() is used to wait for all promises to settle, and the results are returned.

These are just two examples of how you can call async/await functions in parallel using JavaScript. Depending on your specific use case, you may need to choose one over the other. Experiment with both methods to determine which one works best for your needs.

Remember to handle any errors that may occur during the execution of the promises using catch() or try/catch blocks.

Happy coding!