Niche Portobello Mushroom

    fast-loops

    1.1.3 • Public • Published

    Fast Loops

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

    TravisCI Test Coverage gzipped size npm downloads npm version

    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.

    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]

    arrayFilter(arr, filter)

    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]

    arrayMap(arr, mapper)

    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]

    arrayReduce(arr, reducer, accumulator)

    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

    objectEach(obj, iterator)

    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 }

    objectFilter(obj, filter)

    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 }

    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.

    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"

    objectMap(obj, mapper)

    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 }

    objectReduce(obj, reducer, accumulator)

    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

    objectRenameKeys(obj, keys)

    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 }

    objectMergeDeep(base, ...objs)

    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 }

    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.

    Install

    npm i fast-loops

    DownloadsWeekly Downloads

    38,047

    Version

    1.1.3

    License

    MIT

    Unpacked Size

    93 kB

    Total Files

    53

    Last publish

    Collaborators

    • rofrischmann