Fast Loops

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

TravisCI npm downloads

Installation

yarn add fast-loops

Alternatively use npm i --save fast-loops.

Why?

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.

API

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

arrayEach
arrayFilter
arrayMap
arrayReduce
objectEach
objectFilter
objectFind
objectMap
objectReduce
objectRenameKeys
objectMergeDeep

`arrayEach(arr, iterator)`

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

arr (Array): The array to iterate over
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]

`arrayFilter(arr, filter)`

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

arr (Array): The array that gets filtered
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]

`arrayMap(arr, mapper)`

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

arr (Array): The array that gets mapped
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]

`arrayReduce(arr, reducer, accumulator)`

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

arr (Array): The array that gets reduced
reducer (Function): The reducer method with the signature (accumulator, value, index, length, arr) => accumulator
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

`objectEach(obj, iterator)`

Iterates over each key in the object.

obj (Object): The object to iterate over
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 }

`objectFilter(obj, filter)`

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

obj (Object): The object that gets filtered
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 }

`objectFind(obj, query)`

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.

obj (Object): The object that gets queried
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"

`objectMap(obj, mapper)`

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

obj (Object): The object that gets reduced
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 }

`objectReduce(obj, reducer, accumulator)`

Reduces an object based on the accumulator.

obj (Object): The object that gets reduced
reducer (Function): The reducer method with the signature (accumulator, value, key, obj) => accumulator
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

`objectRenameKeys(obj, keys)`

Renames object keys.

Uses objectReduce under the hood.

obj (Object): The object that gets reduced
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 }

`objectMergeDeep(base, ...objs)`

Recursively merges objects into a base object.

base (Object): The base object which is changed
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 }

Direct Imports

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'

License

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

Current Tags

1.1.4 ... latest (4 months ago)

7 Versions

1.1.4 ... 4 months ago
1.1.3 ... 4 years ago
1.1.2 ... 5 years ago
1.1.1 ... 5 years ago
1.1.0 ... 5 years ago
1.0.1 ... 6 years ago
1.0.0 ... 7 years ago