p-map
Advanced tools
Package description
The p-map npm package is a library that allows you to map over promises concurrently, controlling the number of promises that are running at any given time. It is useful for throttling asynchronous operations that are initiated in a loop, such as API calls, file operations, or any task that returns a promise.
Concurrency Control
This feature allows you to control the number of promises that are executed concurrently. In the code sample, `pMap` is used to fetch a list of URLs with a concurrency limit of 2, meaning only 2 promises will be running at the same time.
const pMap = require('p-map');
const urls = [/* ... */];
const fetchUrl = async url => {/* ... */};
(async () => {
const result = await pMap(urls, fetchUrl, {concurrency: 2});
console.log(result);
})();Error Handling
p-map provides options for error handling. In this example, `stopOnError` is set to false, which means that p-map will not stop mapping over the remaining items when one promise rejects. Instead, it will continue with the rest and collect all the errors.
const pMap = require('p-map');
const tasks = [/* ... */];
const doTask = async task => {/* ... */};
(async () => {
try {
const result = await pMap(tasks, doTask, {concurrency: 4, stopOnError: false});
console.log(result);
} catch (error) {
console.error('An error occurred:', error);
}
})();Promise Cancellation
p-map supports promise cancellation when used with cancelable promises, such as those created with the p-cancelable package. This allows you to cancel the execution of the promises if needed.
const pMap = require('p-map');
const {CancelablePromise} = require('p-cancelable');
const tasks = [/* ... */];
const cancellableTask = task => new CancelablePromise(resolve => {/* ... */});
(async () => {
const mapper = cancellableTask;
const result = await pMap(tasks, mapper, {concurrency: 3});
console.log(result);
})();Bluebird is a comprehensive promise library that includes a 'map' function with concurrency control. It offers a broader set of features for promise manipulation and is often considered a more heavyweight alternative to p-map.
The async library provides a wide range of functions for working with asynchronous code, including 'mapLimit' which is similar to p-map's functionality. Async is callback-based but also supports promises, and it is more general-purpose compared to the more focused p-map.
promise-map-series is a simpler alternative that maps over a list of values in series, resolving promises one after the other, rather than controlling concurrency like p-map.
promise-pool is another library for handling multiple promises concurrently. It provides a pool abstraction that allows you to add tasks to a queue and process them with a controlled concurrency, similar to p-map but with a different API design.
Readme
Map over promises concurrently
Useful when you need to run promise-returning & async functions multiple times with different inputs concurrently.
$ npm install p-map
const pMap = require('p-map');
const got = require('got');
const sites = [
getWebsiteFromUsername('https://sindresorhus'), //=> Promise
'https://ava.li',
'https://github.com'
];
(async () => {
const mapper = async site => {
const {requestUrl} = await got.head(site);
return requestUrl;
};
const result = await pMap(sites, mapper, {concurrency: 2});
console.log(result);
//=> ['https://sindresorhus.com/', 'https://ava.li/', 'https://github.com/']
})();
Returns a Promise that is fulfilled when all promises in input and ones returned from mapper are fulfilled, or rejects if any of the promises reject. The fulfilled value is an Array of the fulfilled values returned from mapper in input order.
Type: Iterable<Promise | unknown>
Iterated over concurrently in the mapper function.
Type: Function
Expected to return a Promise or value.
Type: object
Type: number (Integer)
Default: Infinity
Minimum: 1
Number of concurrently pending promises returned by mapper.
Type: boolean
Default: true
When set to false, instead of stopping when a promise rejects, it will wait for all the promises to settle and then reject with an aggregated error containing all the errors from the rejected promises.
Available as part of the Tidelift Subscription.
The maintainers of p-map and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. Learn more.
Promise.all() but for Map and ObjectFAQs
Map over promises concurrently
We found that p-map demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
CISA launched a new project called Vulnrichment to enrich CVEs with details that help prioritize patching and mitigation efforts, as the NVD backlog of unenriched CVEs awaiting analysis surpasses 10,000.
Security News
Socket is joining forces with CISA and other industry leaders at the RSA Conference to sign the Secure by Design pledge, committing to uphold the highest security standards in our products.
Research
The Socket research team breaks down a sampling of malicious packages that download and execute files, among other suspicious behaviors, targeting the popular Discord platform.