Fast Loops
A collection of small, performant & immutable iteration utilities for Arrays and Objects.
![npm version](https://badge.fury.io/js/fast-loops.svg)
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(arr, iterator)
Iterates over each value in the array.
Similar to Array.prototype.forEach
.
arr
(Array): The array to iterate overiterator
(Function): The iterator method with the signature (value, index, length, arr) => void
import { arrayEach } from 'fast-loops'
arrayEach([1, 2, 3], console.log)
arrayFilter(arr, filter)
Filters an array according to the filter criteria.
Similar to Array.prototype.filter
.
arr
(Array): The array that gets filteredfilter
(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)
arrayMap(arr, mapper)
Maps an array by running the mapper on each value.
Similar to Array.prototype.map
.
arr
(Array): The array that gets mappedmapper
(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)
arrayReduce(arr, reducer, accumulator)
Reduces an array based on the accumulator.
Similar to Array.prototype.reduce
.
arr
(Array): The array that gets reducedreducer
(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)
objectEach(obj, iterator)
Iterates over each key in the object.
obj
(Object): The object to iterate overiterator
(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)
objectFilter(obj, filter)
Filters an object's keys according to the filter criteria.
obj
(Object): The object that gets filteredfilter
(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)
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 queriedquery
(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)
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 reducedmapper
(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)
objectReduce(obj, reducer, accumulator)
Reduces an object based on the accumulator.
obj
(Object): The object that gets reducedreducer
(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)
objectRenameKeys(obj, keys)
Renames object keys.
Uses objectReduce under the hood.
obj
(Object): The object that gets reducedkeys
(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)
objectMergeDeep(base, ...objs)
Recursively merges objects into a base object.
base
(Object): The base object which is changedobjs
(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)
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.