# array-changes-async

> Array diffing

Latest version **3.0.1** (published 2017-11-03) · MIT license · 0 weekly downloads

## Install

```sh
npm install array-changes-async
pnpm add array-changes-async
yarn add array-changes-async
bun add array-changes-async
```

## Health

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

Positive: no vulnerabilities.

Warnings: low downloads; no types; no esm support.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 3.0.1 |
| Published | 2017-11-03 |
| First published | 2015-11-14 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | none |
| Module format | CommonJS |
| Dependencies | 1 |
| Known vulnerabilities | 0 |
| Install scripts | no |
| Author | Dave Brotherstone |
| Maintainers | papandreou, sunesimonsen, bruderstein |
| Keywords | diff |

## Links

- npm: https://www.npmjs.com/package/array-changes-async
- Repository: https://github.com/bruderstein/array-changes-async
- Issues: https://github.com/bruderstein/array-changes-async/issues
- npm.io page: https://npm.io/package/array-changes-async

## Dependencies (1)

- [arraydiff-async](https://npm.io/package/arraydiff-async.md) 0.2.0

## Recent versions

- 3.0.1 (latest) — 2017-11-03
- 3.0.0 — 2016-09-26
- 2.2.1 — 2016-09-14
- 2.2.0 — 2016-04-30
- 2.1.0 — 2016-02-17
- 2.0.2 — 2015-11-16
- 2.0.1 — 2015-11-16
- 2.0.0 — 2015-11-14

## README

# array-changes-async

This is an async port of [array-changes](https://github.com/unexpectedjs/array-changes), to allow for an `equal`
and `similar` functions that accept a callback.  This allows your `equal` and `similar` functions to be asynchronous.

## Original readme from `array-changes`

A library for finding differences between two arrays.

The library was extracted from unexpected and is therefore not
documented and tested properly :-S

(Edit: This async version of the library actually has some more tests, not many, but some :)

## Usage

```js

var arrayChangesAsync = require('array-changes-async');

var leftArray = [ 1, 2, 4 ]
var rightArray = [ 1, 2, 3, 4 ]

function equal(a, b, aIndex, bIndex, callback) {
   // a is the value from the leftArray, aIndex is the index of that item
   // b is the value from the rightArray, bIndex is the index of the item
   // Call the callback function with `true` if a and b are considered equal
   callback(a === b);
}


arrayChangesAsync(leftArray, rightArray, equal, null /* see below */, function (result) {
    
    // result == [ 
    //   { 
    //      type: 'equal', value: 1
    //   },
    //   { 
    //      type: 'equal', value: 2
    //   },
    //   { 
    //      type: 'insert', value: 3
    //   },
    //   { 
    //      type: 'equal', value: 4
    //   }
    // ]
});

```

The fourth parameter allows to define 'similar' items, which has the same signature as the `equal` function, and 
allows to define what is considered similar, ie. 'changed', rather than deleted, and the expected value inserted.

The callbacks receive the `aIndex` and `bIndex` parameters, to allow for memoization, as some items will be tested 
for equality more than once.  This is obviously more useful if you have an async `equal` function that could be
expensive.

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