Integrate `bottleneck` and `p-throttle`
npm install bottleneck-ex> Integrate bottleneck and p-throttle
- Most features of bottleneck
- Useful rate limiting
- Simple map function wrapper
> $ npm install --save bottleneck-ex
>
> $ yarn add bottleneck-ex
Here, the trottled function is called fifth a second:
``javascript
const BottleneckEx = require('bottleneck-ex')
const limiter = new BottleneckEx({ratePerSecond: 5})
const now = Date.now()
const throttled = (n, i) => {
const secDiff = ((Date.now() - now) / 1000).toFixed()
return Promise.resolve((${i}, ${n}): ${secDiff}s)
}
async function test1 () {
const operations = [1, 2, 3, 4, 5, 6]
const msg = await limiter.map(operations, (each, index) => throttled(each, index))
return msg
}
async function test2 () {
const operations = ['a', 'b', 'c', 'd', 'e', 'f']
const msg = await limiter.map(operations, (each, index) => throttled(each, index))
return msg
}
async function test () {
const results = await Promise.all([test1(), test2()])
return results
}
test().then(console.log)
// [ [ '(0, 1): 0s',
// '(1, 2): 0s',
// '(2, 3): 0s',
// '(3, 4): 0s',
// '(4, 5): 0s',
// '(5, 6): 1s' ],
// [ '(0, a): 1s',
// '(1, b): 1s',
// '(2, c): 1s',
// '(3, d): 1s',
// '(4, e): 2s',
// '(5, f): 2s' ] ]
`
Constructor: BottleneckEx is a subclass of Bottleneck
> const limiter = new BottleneckEx(options)
- options.maxConcurrent : How many requests can be running at the same time. Default: 0 (unlimited)options.minTime
- : How long to wait after launching a request before launching another one. Default: 0msoptions.highWater
- : How long can the queue get? Default: -1 (unlimited)options.strategy
- : Which strategy to use if the queue gets longer than the high water mark. Default: Bottleneck.strategy.LEAK.options.rejectOnDrop
- : When true if a job is dropped its callback will be called with the first argument set to an Error object. If the job was a promise it will be rejected. Default: falseoptions.ratePerSecond
- : Rate limit per second. Must be positive, like 0.5 , 1..etc. Default: 1
Returns a Prmomise which resolves all fn's processing results for array.
> const promise = limiter.map(operations, (each, index) => throttled(each, index))
- array: Array to be processed.fn
- : Function, both sync or async function are available.
Most APIs supported by bottleneck`