# function-loop

> Run a list of functions in order in a given object context. The functions can be callback-taking or promise-returning.

Latest version **4.0.0** (published 2023-04-09) · ISC license · 0 weekly downloads

## Install

```sh
npm install function-loop
pnpm add function-loop
yarn add function-loop
bun add function-loop
```

## Health

**Score 40/100 (D)** — status: abandoned.

Positive: has types; esm support; no vulnerabilities; high quality score.

Warnings: low downloads.

Negative: abandoned.

## Facts

| | |
|---|---|
| Version | 4.0.0 |
| Published | 2023-04-09 |
| First published | 2017-01-19 |
| Weekly downloads | 0 |
| License | ISC |
| TypeScript types | bundled |
| Module format | ESM + CommonJS |
| Dependencies | 0 |
| Unpacked size | 9.1 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| GitHub stars | 14 |
| Author | Isaac Z. Schlueter |
| Maintainers | isaacs |

## Links

- npm: https://www.npmjs.com/package/function-loop
- Repository: https://github.com/isaacs/function-loop
- Homepage: https://github.com/isaacs/function-loop#readme
- Issues: https://github.com/isaacs/function-loop/issues
- npm.io page: https://npm.io/package/function-loop

## Recent versions

- 4.0.0 (latest) — 2023-04-09
- 3.0.1 — 2023-03-22
- 3.0.0 — 2022-11-29
- 2.0.1 — 2021-02-16
- 2.0.0 — 2021-02-16
- 1.0.2 — 2019-03-28
- 1.0.1 — 2017-01-19
- 1.0.0 — 2017-01-19

## README

# function-loop

Run a list of synchronous or asynchronous functions, and call a
function at the end.

## USAGE

```ts
import { loop } from 'function-loop'
// or `const { loop } = require('function-loop')

const loop = require('./dist/cjs/index.js').default

// synchronous usage
const list = [
  () => console.log(1),
  () => console.log(2),
  () => console.log(3),
]
const result = loop(list, () => {
  console.log('done')
  return true
}, (er) => {
  console.error('threw somehow', er)
})

console.log('result:', result)
// logs:
// 1
// 2
// 3
// done
// result: true

// asynchronous usage
const plist = [
  async () => console.log(1),
  async () => new Promise(resolve => setTimeout(resolve, 100)).then(() =>
    console.log(2)
  ),
  async () => console.log(3),
]
const presult = loop(plist, () => {
  console.log('done')
  return true
}, (er) => {
  console.error('threw somehow', er)
})

console.log('result:', presult)
presult.then(() => console.log('resolved'))
// logs:
// 1
// result: Promise { <pending> }
// 3
// 2
// resolved
```

## Zalgo Preserving

This module is
["zalgo-preserving"](http://blog.izs.me/post/59142742143/designing-apis-for-asynchrony),
meaning that synchronous returns will result in a sync call to
the supplied cb, and async calls will result in the done callback
being called asynchronously.  The loop will return a Promise
indicating when it is finished, if any async functions are
encountered.  It does not artificially defer if functions are
called synchronously.

## API

`loop(functionList, doneCallback, errorCallback)`

Run all the functions and then call the `doneCallback` or call
the `errorCallback` if there are any errors.

Functions are called without being bound to any object as `this`.

Functions can return a Promise to do async operations, or not if
they are done synchronously.  Throws and Promise rejection are
reported to the `errorCallback` provided.

Return value is the return value of the callback, or a `Promise`
resolving to the callback's return value if any of the functions
in the list return promises.

---
_Source: https://npm.io/package/function-loop · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._