Package Exports

async-array-methods

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (async-array-methods) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

async-array-methods

Async methods to manipulate arrays.

Usage

var methods = require('async-array-methods')
var AsyncArray = methods.Array
var filter = methods.filter
var map = methods.map
var forEach = methods.forEach
var reduce = methods.reduce

All methods return a promise.

filter
map
series
forEach
reduce
AsyncArray

Methods

Callbacks can be made asynchronous by returning a promise, or accepting a function argument, which will be called when the callback finishes.

Otherwise, the callback is treated as synchronous.

filter

Signature: filter(arr, fn, context)

filter(
  [1, 2, 3, 4],
  function (v, i, a, next) {
    process.nextTick(function () {
      next(null, v % 2)
    })
  }
)
.then(function (res) {
  // [1, 3]
  console.log(res)
})

map

Signature: map(arr, fn, context)

fn is called with each element in parallel.

map(
  [1, 2, 3, 4],
  function (v) {
    return new Promise(function (rs) {
      process.nextTick(function () {
        rs(v << 2)
      })
    })
  },
  { num: 2 }
)
// [4, 8, 12, 16]
.then(console.log.bind(console))

series

This method works like map, except that fn is called with each element in sequence rather than in parallel.

Signature: map(arr, fn, context)

var n = 1
series(
  [1, 2, 3, 4],
  function (v, i, arr, next) {
    var delay = rand()
    console.log('i:', i, 'delay:', delay)
    setTimeout(function() {
      next(null, v << n++)
    }, delay)
  }
)
// i: 0 delay: 10
// i: 1 delay: 50
// i: 2 delay: 0
// i: 3 delay: 80
// [2, 8, 24, 64]
.then(log)

function rand() {
  return Math.floor(Math.random() * 10) * 10
}

forEach

fn is called with elements in sequence.

Signature: forEach(arr, fn, context)

var count = 0

forEach(
  [1, 2, 3, 4],
  function (v, i, _, next) {
    process.nextTick(function () {
      console.log(count++, i)
      next(null, v << 2)
    })
  }
)
.then(function (arr) {
  // [1, 2, 3, 4]
  console.log(arr)
})

reduce

Signature: reduce(arr, fn, initial)

reduce(
  [1, 2, 3, 4],
  function (a, b, i, arr, next) {
    process.nextTick(function () {
      next(null, a + b)
    })
  }
)
// 10
.then(console.log.bind(console))

AsyncArray

Signature: AsyncArray(arr)

Methods:

map
series
filter
forEach
reduce

var origin = AsyncArray([1, 2, 3, 4, 5, 6])
var odd = origin.filter(isOdd)
var even = origin.filter(isEven)

return odd.then(function (res) {
  // [1, 3, 5]
  console.log(res)
  return even
})
.then(function (res) {
  // [2, 4, 6]
  console.log(res)
})
.then(function () {
  return even.reduce(flagMap, {})
})
.then(function (res) {
  // { 2: true, 4: true, 6: true }
  console.log(res)
})
.then(function () {
  // chain
  return origin.filter(isOdd).reduce(flagMap, {})
})
.then(function (res) {
  // { 1: true, 3: true, 5: true }
  console.log(res)
})

function isOdd(n, i, arr, next) {
  process.nextTick(function () {
    next(null, n % 2)
  })
}

function isEven(n, i, arr, next) {
  return new Promise(function (resolve) {
    process.nextTick(function () {
      resolve((n + 1) % 2)
    })
  })
}

function flagMap(o, v) {
  o[v] = true
  return o
}