lodash

What is lodash?

Lodash is a JavaScript library that provides utility functions for common programming tasks using a functional programming paradigm. It includes functions for manipulating and traversing arrays, objects, and strings, as well as utilities for functions, language, math, number, object, sequence, and utility methods.

What are lodash's main functionalities?

Array Manipulation

Lodash provides a rich set of array manipulation functions such as map, filter, find, and sort. The code sample demonstrates sorting an array in ascending order using a custom comparator.

[3, 2, 1].sort(_.compareWith(function(a, b) { return a - b; }))

Object Manipulation

Lodash allows for easy manipulation and traversal of objects. The code sample shows how to assign properties from source objects to a destination object.

_.assign({ 'a': 1 }, { 'b': 2 }, { 'c': 3 })

String Manipulation

Lodash includes functions to manipulate strings, such as converting to different cases, trimming, padding, etc. The code sample demonstrates converting a string to kebab-case.

_.kebabCase('Foo Bar')

Function Utilities

Lodash provides function utilities like debounce and throttle to control function invocation. The code sample shows a debounced function that will only be invoked after 250 milliseconds have passed without it being called again.

_.debounce(function() { console.log('Debounced'); }, 250)

Language Utilities

Lodash includes utilities for deep cloning, merging, and comparing objects. The code sample demonstrates deep cloning an object to ensure nested objects are cloned as well.

_.cloneDeep({ 'a': 1, 'b': { 'c': 2 } })

Other packages similar to lodash

underscore

Underscore is a utility library with similar functionality to Lodash, offering a range of functions for manipulating arrays, objects, and functions. It is generally considered to be the predecessor to Lodash, which provides a superset of Underscore's features with additional performance optimizations.

ramda

Ramda is a functional programming library that emphasizes a more functional and composable approach compared to Lodash. It provides similar utilities but focuses on immutability and side-effect free functions, which can lead to a different programming style.

immutable

Immutable.js offers a different take on data manipulation by providing persistent immutable data structures. Unlike Lodash, which works with standard JavaScript objects and arrays, Immutable.js uses its own data structures, which can lead to better performance and easier reasoning about state changes in certain applications.

README

Lo-Dash v2.0.0

A utility library delivering consistency, customization, performance, & extras.

Download

• Modern builds: Development & Production

• Compatibility builds: Development & Production

• Underscore builds: Development & Production

Love modules? We’ve got you covered with lodash-amd, lodash-node, and npm packages per method.

CDN copies are available on cdnjs & jsDelivr.
For smaller file sizes, create custom builds with only the features needed.

Dive in

There’s plenty of documentation, unit tests, & benchmarks.

For a list of upcoming features, check out our roadmap.

Features not in Underscore

• AMD loader support (curl, dojo, requirejs, etc.)
• _(…) supports intuitive chaining
• _.at for cherry-picking collection values
• _.bindKey for binding “lazy” defined methods
• _.cloneDeep for deep cloning arrays & objects
• _.contains accepts a fromIndex
• _.createCallback for extending callbacks in methods & mixins
• _.curry for creating curried functions
• _.debounce & _.throttle accept options for more control
• _.findIndex & _.findKey for finding indexes & keys
• _.forEach is chainable & supports exiting early
• _.forIn for iterating own & inherited properties
• _.forOwn for iterating own properties
• _.isPlainObject for checking if values are created by Object
• _.memoize exposes the cache of memoized functions
• _.merge for a deep _.extend
• _.parseInt for consistent behavior
• _.partialRight for partial application from the right
• _.pull & _.remove for mutating arrays
• _.runInContext for easier mocking
• _.support for flagging environment features
• _.template supports “imports” options & ES6 template delimiters
• _.transform as a powerful alternative to _.reduce for transforming objects
• _.where supports deep object comparisons
• _.zip is capable of unzipping values
• _.omit, _.pick, & more accept callbacks
• _.contains, _.toArray, & more accept strings
• _.filter, _.map, & more support “_.pluck” & “_.where” shorthands
• _.findLast, _.findLastIndex, & more right-associative methods

Resources

• Posts

• Say “Hello” to Lo-Dash
• Custom builds in Lo-Dash 2.0

• Videos

• Introduction
• Origins
• Optimizations & builds
• Native method use
• Testing
• CascadiaJS ’12

Support

Tested in Chrome 529, Firefox 223, IE 6-10, Opera 9.25~15, Safari 3-6, Node.js 0.6.8-0.10.18, Narwhal 0.3.2, PhantomJS 1.9.1, RingoJS 0.9, & Rhino 1.7RC5.

Installation & usage

In browsers:

<script src="lodash.js"></script>

Using npm:

npm i lodash

{sudo} npm i -g lodash
npm link lodash

In Node.js & Ringo:

var _ = require('lodash');
// or as Underscore
var _ = require('lodash/dist/lodash.underscore');

Notes:

• Don’t assign values to special variable _ when in the REPL
• If Lo-Dash is installed globally, run npm link lodash in your project’s root directory before requiring it
• Node.js 0.10.8-0.10.11 have bugs preventing minified builds

In Rhino:

load('lodash.js');

In an AMD loader:

require({
  'packages': [
    { 'name': 'lodash', 'location': 'path/to/lodash', 'main': 'lodash' }
  ]
},
['lodash'], function(_) {
  console.log(_.VERSION);
});

Release Notes

^v2.0.0

Compatibility Warnings

• Aligned _.after with Underscore 1.5.0, making it always return a function

Noteable Changes

• Created Lo-Dash methods as npm packages & AMD/Node.js modules
• Made _.chain force chaining for all methods, even those that normally return unwrapped values
• Moved the build utility to lodash-cli
• Optimized _.contains, _.debounce, _.isArguments, _.throttle, _.where,
  & functions created by _.bind, _.bindKey, _.curry, _.partial, & _.partialRight
• Added _.curry, _.forEachRight, _.indexBy, _.findLast, _.findLastIndex,
  _.findLastKey, _.forInRight, _.forOwnRight, _.pull, _.remove, & _.sample

Other Changes

• Added Curl & Dojo module loaders to the unit tests
• Added the modularize build option
• Added support for the iife command to be used without an %output% token
• Added support for _.mixin to accept a destination object
• Added support for _.range to accept a step of 0
• Added _.eachRight as an alias for _.forEachRight
• Ensured “Arrays” methods support arguments objects
• Ensured “Functions” methods throw when not passed functions
• Ensured _.at works as a callback for _.map
• Ensured _.createCallback works when no argCount is specified
• Ensured _.first & _.last return arrays when passed a falsey array with an n value
• Ensured _.flatten works with arguments objects
• Ensured minified files work with Dojo’s builder
• Ensured _.zipObject skips falsey elements
• Improved dead code removal from builds
• Improved JSDoc syntax
• Made _.memoize avoid prefixing cache keys when using a resolver function
• Made _.unzip an alias of _.zip
• Removed local clearTimeout & setTimeout variables from the underscore build
• Reduced the size of the repo & npm package
• Simplified the bailout in createCache
• Updated sourceURL & sourceMappingURL syntax
• Updated underscore build compatibility to v1.5.2

The full changelog is available here.

BestieJS

Lo-Dash is part of the BestieJS “Best in Class” module collection. This means it promotes solid environment support, ES5+ precedents, unit testing, & plenty of documentation.

Author

John-David Dalton

Contributors

Blaine Bublitz	Kit Cambridge	Mathias Bynens