# fast-loops > Small, performant & immutable iteration utilities for Arrays and Objects Latest version **1.1.4** (published 2024-07-04) · MIT license · 0 weekly downloads ## Install ```sh npm install fast-loops pnpm add fast-loops yarn add fast-loops bun add fast-loops ``` ## Health **Score 20/100 (F)** — status: abandoned. Positive: esm support; no vulnerabilities. Warnings: low downloads; no types. Negative: abandoned; low maintenance score. ## Facts | | | |---|---| | Version | 1.1.4 | | Published | 2024-07-04 | | First published | 2017-11-26 | | Weekly downloads | 0 | | License | MIT | | TypeScript types | none | | Module format | ESM + CommonJS | | Dependencies | 0 | | Unpacked size | 31.8 KB | | Known vulnerabilities | 0 | | Install scripts | no | | GitHub stars | 29 | | Author | robinweser | | Maintainers | rofrischmann | | Keywords | fast loops, utility, minimal, small | ## Links - npm: https://www.npmjs.com/package/fast-loops - Repository: https://github.com/robinweser/fast-loops - Homepage: https://github.com/robinweser/fast-loops#readme - Issues: https://github.com/robinweser/fast-loops/issues - npm.io page: https://npm.io/package/fast-loops ## Alternatives - [lodash.assign](https://npm.io/package/lodash.assign.md) — 2.3M weekly downloads - [lodash.chunk](https://npm.io/package/lodash.chunk.md) — 1.8M weekly downloads - [react-native-ios-utilities](https://npm.io/package/react-native-ios-utilities.md) — 138.5K weekly downloads - [@technically/lodash](https://npm.io/package/@technically/lodash.md) — 50.9K weekly downloads - [@fluid-topics/ft-icon](https://npm.io/package/@fluid-topics/ft-icon.md) — 20.6K weekly downloads ## Recent versions - 1.1.4 (latest) — 2024-07-04 - 1.1.3 — 2020-10-02 - 1.1.2 — 2019-11-19 - 1.1.1 — 2019-09-13 - 1.1.0 — 2019-09-13 - 1.0.1 — 2018-06-29 - 1.0.0 — 2017-11-26 ## README # Fast Loops A collection of small, performant & immutable iteration utilities for Arrays and Objects. TravisCI Test Coverage gzipped size npm downloads npm version ## Installation ```sh 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](#arrayeacharr-iterator) * [arrayFilter](#arrayfilterarr-filter) * [arrayMap](#arraymaparr-mapper) * [arrayReduce](#arrayreducearr-reducer-accumulator) * [objectEach](#objecteachobj-iterator) * [objectFilter](#objectfilterobj-filter) * [objectFind](#objectfindobj-query) * [objectMap](#objectmapobj-mapper) * [objectReduce](#objectreduceobj-reducer-accumulator) * [objectRenameKeys](#objectrenamekeysobj-keys) * [objectMergeDeep](#objectmergedeepbase-objs) ### `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` ```javascript 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` ```javascript 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` ```javascript 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 ```javascript 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` ```javascript 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` ```javascript 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` ```javascript 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` ```javascript 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 ```javascript 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](#objectreduceobj-reducer-accumulator) under the hood. 1. `obj` (*Object*): The object that gets reduced 2. `keys` (*Object*): The keys mapping an old key to a new key ```javascript 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\*): A list of objects to be merged into the base object ```javascript 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. ```javascript import objectReduce from 'fast-loops/lib/objectReduce' ``` ## License fast-loops is licensed under the [MIT License](http://opensource.org/licenses/MIT).
Documentation is licensed under [Creative Common License](http://creativecommons.org/licenses/by/4.0/).
Created with ♥ by [@rofrischmann](http://rofrischmann.de). --- _Source: https://npm.io/package/fast-loops · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._