Parallel with Limit

Run promises in parallel with a concurrency limit to control resource usage and prevent overwhelming external services.

Code

Boilerplates

const parallelLimit = async (arr, fn, concurrency) => {
  const results = [];
  const executing = new Set();
  for (const item of arr) {
    const p = Promise.resolve(fn(item)).then(r => {
      executing.delete(p);
      return r;
    });
    executing.add(p);
    results.push(p);
    if (executing.size >= concurrency) await Promise.race(executing);
  }
  return Promise.all(results);
};

const results = await parallelLimit([1,2,3,4,5], x => x * 2, 2);
return results.join(',');

Browser·fetch() may be limited by CORS

More JavaScript Snippets

Debounce

Create a debounced function that delays execution until after a specified wait period has elapsed since the last call.

Memoize

Cache function results to avoid redundant calculations and improve performance for expensive operations.

Once

Create a function that can only be called once, returning the cached result for subsequent invocations.

Promise.allSettled

Wait for all promises to settle, whether they resolve or reject.

Promise.any

Return the result of the first promise that resolves successfully.

Retry with Backoff

Retry an async function with exponential backoff to handle transient failures gracefully.