A collection of small, performant & immutable iteration utilities for Arrays and Objects.

yarn add fast-loops

Alternatively use npm i --save fast-loops.

Because JavaScript's native "functional" APIs such as forEach, reduce, map and filter are slow. There're many different utility packages out there already, e.g. lodash. But lodash's reduce method itself is 4.5kb gzipped which is way too much for a simple Array/Object reduce utility.

All methods are immutable by defaults, yet they're not safe from mutating.

• arrayEach
• arrayFilter
• arrayMap
• arrayReduce
• objectEach
• objectFilter
• objectFind
• objectMap
• objectReduce
• objectRenameKeys
• objectMergeDeep

Iterates over each value in the array.
Similar to Array.prototype.forEach.

1. arr (Array): The array to iterate over
2. iterator (Function): The iterator method with the signature (value, index, length, arr) => void

import { arrayEach } from 'fast-loops'

arrayEach([1, 2, 3], console.log)
// 1, 0, 3, [1, 2, 3]
// 2, 1, 3, [1, 2, 3]
// 3, 2, 3, [1, 2, 3]

Filters an array according to the filter criteria.
Similar to Array.prototype.filter.

1. arr (Array): The array that gets filtered
2. filter (Function): The filter method with the signature (value, index, length, arr) => boolean

import { arrayFilter } from 'fast-loops'

const biggerThan2 = arrayFilter([1, 2, 3, 4], value => value > 2)

console.log(biggerThan2)
// => [3, 4]

Maps an array by running the mapper on each value.
Similar to Array.prototype.map.

1. arr (Array): The array that gets mapped
2. mapper (Function): The mapping method with the signature (value, index, length, arr) => newValue

import { arrayMap } from 'fast-loops'

const square = arrayMap([1, 2, 3, 4], value => value * value)

console.log(square)
// => [1, 4, 9, 16]

Reduces an array based on the accumulator.
Similar to Array.prototype.reduce.

1. arr (Array): The array that gets reduced
2. reducer (Function): The reducer method with the signature (accumulator, value, index, length, arr) => accumulator
3. accumulator (any): The initial accumulator value

import { arrayReduce } from 'fast-loops'

const sum = arrayReduce([1, 2, 3, 4], (out, value) => out + value, 0)

console.log(sum)
// => 10

Iterates over each key in the object.

1. obj (Object): The object to iterate over
2. iterator (Function): The iterator method with the signature (value, key, obj) => void

import { objectEach } from 'fast-loops'

objectEach({ 1: 10, 2: 20, 3: 30 }, console.log)
// 10, 1, { 1: 10, 2: 20, 3: 30 }
// 20, 2, { 1: 10, 2: 20, 3: 30 }
// 30, 3, { 1: 10, 2: 20, 3: 30 }

Filters an object's keys according to the filter criteria.

1. obj (Object): The object that gets filtered
2. filter (Function): The filter method with the signature (value, key, obj) => boolean

import { objectFilter } from 'fast-loops'

const filter = (value, key) => value > 20 && parseInt(key) % 2 !== 0
const biggerThan20AndOddKey = objectFilter({ 1: 10, 2: 20, 3: 30, 4: 40 }, filter)

console.log(biggerThan20AndOddKey)
// => { 3: 30 }

Tries to find a key-value pair that matches the query.
Returns the matching key or undefined if none matches.
It's like Array.prototype.find but for objects.

1. obj (Object): The object that gets queried
2. query (Function): The query method with the signature (value, key, obj) => boolean

import { objectFind } from 'fast-loops'

const query = (value, key) => value > 20 && parseInt(key) % 2 === 0
const biggerThan20AndEvenKey = objectFind({ 1: 10, 2: 20, 3: 30, 4: 40 }, query)

console.log(biggerThan20AndEvenKey)
// => "4"

Maps an object by running the mapper on each value.
Similar to Object.keys(obj).map(mapper).

1. obj (Object): The object that gets reduced
2. mapper (Function): The mapper method with the signature (value, key, obj) => newValue

import { objectMap } from 'fast-loops'

const mapped = objectMap({ 1: 10, 2: 20, 3: 30 }, (value, key) => value + parseInt(key))

console.log(mapped)
// => { 1: 11, 2: 22, 3: 33 }

Reduces an object based on the accumulator.

1. obj (Object): The object that gets reduced
2. reducer (Function): The reducer method with the signature (accumulator, value, key, obj) => accumulator
3. accumulator (any): The initial accumulator value

import { objectReduce } from 'fast-loops'

const sumOfValues = objectReduce({ 1: 10, 2: 20, 3: 30 }, (out, value) => out + value, 0)

console.log(sumOfValues)
// => 60

Renames object keys.

Uses objectReduce under the hood.

1. obj (Object): The object that gets reduced
2. keys (Object): The keys mapping an old key to a new key

import { objectRenameKeys } from 'fast-loops'

const renamedObj = objectRenameKeys({ foo: 1, bar: 2 }, { foo: "baz" })

console.log(sumOfValues)
// => { baz: 1, bar: 2 }

Recursively merges objects into a base object.

1. base (Object): The base object which is changed
2. objs (Array<Object>): A list of objects to be merged into the base object

import { objectMergeDeep } from 'fast-loops'

const base = {
  foo: 1,
  bar: {
    foo: 2
  }
}
const mergedObj = objectMergeDeep(base, { baz: 3 }, { bar: { foo: 3 }})

console.log(mergedObj)
// => { foo: 1, bar: { foo: 3 }, baz: 3 }

While we support the module key to support Tree Shaking, you might still want to import single methods without any overhead. You can import every method using the full path to the method resource.

import objectReduce from 'fast-loops/lib/objectReduce'

fast-loops is licensed under the MIT License.
Documentation is licensed under Creative Common License.
Created with ♥ by @rofrischmann.