setInterval with setTimeout semantics for promises and async/await
npm install interval-promise
This library provides a simple mechanism for running a promise with a given amount of time between executions.
#### Standard Javascript » setInterval()
#### interval-promise » interval()
``bash`
npm install interval-promise
Simple example using async-await
`javascript
const interval = require('interval-promise')
// Run a function 10 times with 1 second between each iteration
interval(async () => {
await someOtherPromiseReturningFunction()
await another()
}, 1000, {iterations: 10})
`
`javascript`
interval(func, intervalLength, options = {}) // returns Promise
| Argument | Attritubes | Description |
|---|---|---|
func | function | Required Function to execute for each interval. MUST return a promise. Two arguments are passed to this function.
|
intervalLength | number | function | Required Length in ms to wait between iterations. Should be (or return) a non-negative integer. If a function is used, one parameter iterationNumber (starting at 1) is passed. |
options | object | Optional settings (detailed below). |
options.iterations | number | Default: InfinityThe number of times to execute the function. Must be Infinity or an integer greater than 0. |
options.stopOnError | boolean | Default: trueIf true, no subsequent calls will be made. The promise returned by interval() will be rejected and pass through the error thrown. |
* Approachability — Basic usage should be concise and readable.
* Debuggability — Error feedback should be helpful and error handling options should be flexible.
* Stability — Functionality should be well-tested and reliable.
This library was inspired by reissue.
There isn't currently direct feature to stop the iterations externally. You can, however, achieve this by checking a variable in the parent scope (of where the function is defined). Check out the code below.
`js
const interval = require('interval-promise')
let stoppedExternally = false
const stopExternally = () => { stoppedExternally = true }
interval(async (iteration, stop) => {
if (stoppedExternally) {
stop()
}
// ... normal functionality ...
}, 1000)
// Some other work...
someOtherWork().then(() => {
// Now that our "other work" is done, we can stop our interval above with:
stopExternally()
})
``