Skip to content
Provide async/await callbacks for every, find, findIndex, filter, forEach, map, reduce, reduceRight and some methods in Array.
Branch: master
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
doc
examples
lib
test
.gitignore
.npmignore
.prettierignore
.prettierrc
.travis.yml
CODE_OF_CONDUCT.md
LICENSE
README.md
_config.yml
package-lock.json
package.json
tsconfig.json
tslint.json

README.md

Async-Ray

License Version Language grade: JavaScript Codacy Badge Codacy Badge Build Status Known Vulnerabilities Maintainability

Purpose of this package is to provide async/await callbacks for every, filter, find, findIndex, forEach, map, reduce, reduceRight and some methods in Array.

TypeScript Doc: https://rpgeeganage.github.io/async-ray/doc/

Content

Basic usage

const { AsyncRay } = require('async-ray');

Supported methods

.aEvery

.aEvery(async callback(element[, index[, array]]))
async function dummy(element, needle) {
  return Promise.resolve(element > needle);
}

const inputArray = [10, 20, 30, 40];

// Call Every method
const output = await AsyncRay(inputArray).aEvery(
  async (i, index, collection) => {
    // Dummy async function
    return await dummy(i, 5);
  }
);

console.log(output);
// Output is true

.aFilter

.aFilter(async callback(element[, index[, array]]))
async function dummy(element, needle) {
  return Promise.resolve(element > needle);
}

const inputArray = [1, 2, 3, 4];

// Call Filter method
const filterArray = await AsyncRay(inputArray).aFilter(
  async (i, index, collection) => {
    // Dummy async function
    return await dummy(i, 2);
  }
);

console.log(filterArray);
// Output is [3, 4]

.aFind

.aFind(async callback(element[, index[, array]]))

Find will return the found value or undefined

async function dummy(element, needle) {
  return Promise.resolve(element === needle);
}

const inputArray = [1, 2, 3, 4];

// Call Find method
const outputElement = await AsyncRay(inputArray).aFind(
  async (i, index, collection) => {
    return await dummy(i, 2);
  }
);

console.log('Output is ', outputElement);
// Output is 2

.aFindIndex

.aFindIndex(async callback(element[, index[, array]]))

FindIndex will return the index of found value or -1

async function dummy(element, needle) {
  return Promise.resolve(element === needle);
}

const inputArray = [1, 2, 3, 4];

// Call Find method
const outputIndex = await AsyncRay(inputArray).aFindIndex(
  async (i, index, collection) => {
    return await dummy(i, 2);
  }
);

console.log('Output is ', outputIndex);
// Output is 1

.aForEach

.aForEach(async callback(element[, index[, array]]))
async function dummy(element) {
  return Promise.resolve(element);
}

const inputArray = [1, 2, 3, 4];
const outputArray = [];

// Call ForEach method
await AsyncRay(inputArray).aForEach(async (i, index, collection) => {
  outputArray.push(await dummy(i));
});

console.log('Output is ', outputArray);
// Output is [1, 2, 3, 4]

.aMap

.aMap(async callback(element[, index[, array]]))
async function dummy(element) {
  return Promise.resolve(element);
}

const inputArray = [1, 2, 3, 4];

// Call Map method
const mappedArray = await AsyncRay(inputArray).aMap(
  async (i, index, collection) => {
    // Dummy async function
    return await dummy(i);
  }
);
console.log(mappedArray);
// Output is [1, 2, 3, 4]

.aReduce

.aReduce(async callback(accumulator, element[, index[, array]]), [initialValue])
async function dummy(element) {
  return Promise.resolve(element);
}

const inputArray = [10, 20, 30, 40];

// Call Reduce method
const output = await AsyncRay(inputArray).aReduce(
  async (acc, i, index, collection) => {
    return acc + (await dummy(i));
  },
  1
);

console.log('Output is ', output);
// Output is 101

.aReduceRight

.aReduceRight(async callback(accumulator, element[, index[, array]]), [initialValue])
async function dummy(element) {
  return Promise.resolve(element);
}

const inputArray = [10, 20, 30, 40];

// Call Reduce method
const output = await AsyncRay(inputArray).aReduceRight(
  async (acc, i, index, collection) => {
    return acc + (await dummy(i));
  },
  1
);

console.log('Output is ', output);
// Output is 101

.aSome

.aSome(async callback(element[, index[, array]]))
async function dummy(element, needle) {
  return Promise.resolve(element > needle);
}

const inputArray = [10, 20, 30, 40];

// Call Some method
const output = await AsyncRay(inputArray).aSome(
  async (i, index, collection) => {
    // Dummy async function
    return await dummy(i, 30);
  }
);

console.log(output);
// Output is true

Using methods individually

You can use each method without creating AsyncRay object.

import {
  aEvery, aFilter, aFind, aFindIndex,
  aForEach, aMap, aReduce, aReduceRight, aSome
} from 'async-ray';

// aEvery
const everyResult = await aEvery(
  [1, 2, 3],
  async (e) => Promise.resolve(e > 0)
);

// aFilter
const filterResult = await aFilter(
  [1, 2, 3],
  async (e) => Promise.resolve(e > 1)
);

// aFind
const findResult = await aFind(
  [1, 2, 3],
  async (e) => Promise.resolve(e === 3)
);

// aFindIndex
const findIndexResult = await aFindIndex(
  [1, 2, 3],
  async (e) => Promise.resolve(e === 2)
);

// aForEach
const forEachResult: number[] = [];
await aForEach(
  [1, 2, 3],
  async (e) => {
    const op = await Promise.resolve(e * 10);
	  forEachResult.push(op);
  }
);

// aMap
const mapResult = await aMap(
  [1, 2, 3],
  async (e) => Promise.resolve(e * 10)
);

// aReduce
const reduceResult = await aReduce(
  [1, 2, 3],
  async (acc, e) => Promise.resolve(e + acc),
  0
);

// aReduceRight
const reduceRightResult = await aReduceRight(
  [1, 2, 3],
  async (acc, e) => Promise.resolve(e + acc),
  0
);

// aSome
const someResult = await aSome(
  [1, 2, 3],
  async (e) => Promise.resolve(e > 1)
);

Chaining

Async-Ray methods can be chained using Chain functionality

Basic usage

const { Chain } = require('async-ray');

Chaining will return an instance of Async-Ray if returned type is an array.


sample 1 - aMap() and aFilter()

(sample code)

The process() method must be called explicitly to process the chain because aMap() and aFilter() method returns an array.

const input = [1, 2, 3];

const op = await Chain(input)
  .aMap(
    async (e) => Promise.resolve(e * 10)
  )
  .aFilter(
    async (e) => Promise.resolve(e > 10)
  )
  .aMap(
    async (e) => Promise.resolve(e * 10)
  )
  // Call the process() method to execute the chain
  .process();

console.log('Output is ', op);
// Output is [ 200, 300 ]

sample 2 - aMap(), aFilter() and aFind()

(sample code)

The process() method should not be called because aFind() does not return an array.

const input = [1, 2, 3];

const op = await Chain(input)
  .aMap(
    async (e) => Promise.resolve(e * 10)
  )
  .aFilter(
    async (e) => Promise.resolve(e > 10)
  )
  .aMap(
    async (e) => Promise.resolve(e * 10)
  )
  .aFind(
    async (e) => Promise.resolve(e === 300)
  );
  // No need to call process() method

console.log('Output is ', op);
// Output is 300

Between other Array methods methods


Sample 1 - Async-Ray Chain with filter()

const input = [1, 2, 3];

const op = (
  await Chain(input)
    .aMap(
      async (e) => Promise.resolve(e * 10)
    )
    .aFilter(
      async (e) => Promise.resolve(e > 10)
    )
    .aMap(
      async (e) => Promise.resolve(e * 10)
    )
    .process()
)
.filter(e => e > 200)

console.log('Output is ', op);
// Output is [ 300 ]

Sample 2 - Async-Ray Chain with find()

const input = [1, 2, 3];

const op = (
    await Chain(input)
    .aMap(
      async (e) => Promise.resolve(e * 10)
    )
    .aFilter(
      async (e) => Promise.resolve(e > 10)
    )
    .aMap(
      async (e) => Promise.resolve(e * 10)
    )
    .process()
)
.find(e => e === 200)

console.log('Output is ', op);
// Output is 200
You can’t perform that action at this time.
You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session.