# async-arrays

> Async control for arrays

Latest version **2.0.0** (published 2023-06-19) · MIT license · 0 weekly downloads

## Install

```sh
npm install async-arrays
pnpm add async-arrays
yarn add async-arrays
bun add async-arrays
```

## Health

**Score 20/100 (F)** — status: abandoned.

Positive: esm support; no vulnerabilities.

Warnings: low downloads; no types.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 2.0.0 |
| Published | 2023-06-19 |
| First published | 2013-10-25 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | none |
| Module format | ESM + CommonJS |
| Node | * |
| Dependencies | 1 |
| Unpacked size | 29.3 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| GitHub stars | 0 |
| Author | Abbey Hawk Sparrow |
| Maintainers | khrome |
| Keywords | array, async |

## Links

- npm: https://www.npmjs.com/package/async-arrays
- Repository: https://github.com/khrome/async-arrays
- Issues: https://github.com/khrome/async-arrays/issues
- npm.io page: https://npm.io/package/async-arrays

## Dependencies (1)

- [sift](https://npm.io/package/sift.md) *

## Alternatives

- [@commercetools/sync-actions](https://npm.io/package/@commercetools/sync-actions.md) — 25.1K weekly downloads
- [cwait](https://npm.io/package/cwait.md) — 21.4K weekly downloads
- [@ledgerhq/hw-app-cosmos](https://npm.io/package/@ledgerhq/hw-app-cosmos.md) — 4.2K weekly downloads
- [@financial-times/o-loading](https://npm.io/package/@financial-times/o-loading.md) — 2.8K weekly downloads
- [fa](https://npm.io/package/fa.md) — 185 weekly downloads

## Recent versions

- 2.0.0 (latest) — 2023-06-19
- 1.1.0 — 2023-05-31
- 1.0.1 — 2016-12-20
- 1.0.0 — 2016-12-08
- 0.4.0 — 2015-03-04
- 0.3.0 — 2015-02-12
- 0.2.2 — 2014-06-14
- 0.2.1 — 2014-04-29
- 0.1.1-beta — 2014-02-25
- 0.1.0-beta — 2014-02-16
- 0.0.3-alpha — 2014-02-14
- 0.0.2-alpha — 2014-01-26
- 0.0.1-alpha — 2013-10-25

## README

async-arrays.js
===============

[![NPM version](https://img.shields.io/npm/v/async-arrays.svg)]()
[![npm](https://img.shields.io/npm/dt/async-arrays.svg)]()
[![Travis](https://img.shields.io/travis/khrome/async-arrays.svg)]()

This used to be an array-oriented flow control library. While it still is, [async](https://caolan.github.io/async/v3/) does it more completely.

Now it's just something to use when I want something more lightweight. YMMV

Usage
-----
I find, most of the time, my asynchronous logic emerges from an array and I really just want to be able to control the completion of some job, and have a signal for all jobs. In many instances, this winds up being more versatile than a promise which limits you to a binary state and only groups returns according to it's state. 

you can either retain an instance and use it that way:

    import * as arrays from 'async-arrays';
    // OR: const arrays = require('async-arrays');
    arrays.forEach(array, iterator, calback);
    

`arrays.forEach` : execute serially

    arrays.forEach(array, function(item, index, done){
        somethingAsynchronous(function(){
            done();
        });
    }, function(){
        //we're all done!
    });
    
`arrays.forAll` : execute all jobs in parallel

    arrays.forAll(array, function(item, index, done){
        somethingAsynchronous(function(){
            done();
        });
    }, function(){
        //we're all done!
    });
    
`arrays.forEachBatch` : execute all jobs in parallel up to a maximum #, then queue

    arrays.forEachBatch(array, batchSize, function(item, index, done){
        somethingAsynchronous(function(){
            done();
        });
    }, function(){
        //we're all done!
    });
    
`arrays.map` : map all elements of the array, but allow for asynchronous interaction. Alternatives are: `arrays.map.each`(sequential) `arrays.map.all`(parallel)

    arrays.map(array, function(item, index, done){
        somethingAsynchronous(function(newItem){
            done(newItem);
        });
    }, function(mappedData){
        //we're all done!
    });


Prototype Usage
---------------
Attach to the prototype (using names which don't collide with the browser implementations):

    require('async-arrays').proto();

`forEachEmission` : execute serially

    [].forEachEmission(function(item, index, done){
        somethingAsynchronous(function(){
            done();
        });
    }, function(){
        //we're all done!
    });
    
`forAllEmissions` : execute all jobs in parallel

    [].forAllEmissions(function(item, index, done){
        somethingAsynchronous(function(){
            done();
        });
    }, function(){
        //we're all done!
    });
    
`forAllEmissionsInPool` : execute all jobs in parallel up to a maximum #, then queue for later

    [].forAllEmissionsInPool(poolSize, function(item, index, done){
        somethingAsynchronous(function(){
            done();
        });
    }, function(){
        //we're all done!
    });

`mapEmissions` : map all elements of the array, but allow for asynchronous interaction

    [].mapEmissions(function(item, index, done){
        somethingAsynchronous(function(newItem){
            done(newItem);
        });
    }, function(mappedData){
        //we're all done!
    });
    
###Utility functions
**non mutating**

    ['dog', 'cat', 'mouse'].contains('cat') //returns true;

    ['dog', 'cat'].combine(['mouse']) //returns ['dog', 'cat', 'mouse'];
    
**mutators**
    
    ['dog', 'cat', 'mouse'].erase('cat') //mutates the array to ['dog', 'mouse'];
    
    ['dog', 'cat', 'mouse'].empty('cat') //mutates the array to [];
    

That's just about it, and even better you can open up the source and check it out yourself. Super simple.

Testing
-------
just run
    
    mocha

Enjoy,

-Abbey Hawk Sparrow

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