lodash

Lodash modular utilities.

weekly downloads100.2M

versionv4.17.23

licenseMIT

categoryutility

modulesstdlibutil

Overview

Lodash is a battle-tested JavaScript utility library that provides over 300 functions for manipulating arrays, objects, strings, collections, and functions. Originally forked from Underscore.js, it has evolved into the most downloaded npm package for utilities, averaging over 100 million weekly downloads. The library focuses on consistency, modularity, and performance across different JavaScript environments.

The package addresses JavaScript's gaps in functional programming primitives and cross-browser inconsistencies. While modern ES6+ has native methods like Array.map and Object.assign, Lodash extends far beyond with deep cloning, immutable operations, currying, complex transformations, and safe property access. It maintains backward compatibility with older environments while providing optimizations that often outperform naive native implementations.

Lodash is particularly valuable in enterprise applications where data transformation complexity grows quickly. Its modular architecture allows developers to import only needed functions, reducing bundle size impact. The library offers multiple builds: the full lodash package, lodash/fp for functional programming with auto-curried methods, and individual method imports like lodash/get for precise tree-shaking. This flexibility has made it a standard dependency in React, Vue, and Node.js projects where data manipulation reliability matters more than avoiding external dependencies.

Quick Start

typescript

import _ from 'lodash';
// Or modular: import debounce from 'lodash/debounce';

// API response transformation
const apiUsers = [
  { id: 1, first_name: 'John', last_name: 'Doe', tags: ['admin', 'active'] },
  { id: 2, first_name: 'Jane', tags: ['active'] },
  { id: 3, first_name: null, last_name: 'Smith', tags: [] }
];

// Clean and transform data
const normalized = _.chain(apiUsers)
  .map(user => ({
    id: user.id,
    fullName: _.compact([user.first_name, user.last_name]).join(' ') || 'Anonymous',
    isAdmin: _.includes(user.tags, 'admin'),
    metadata: _.pick(user, ['tags'])
  }))
  .keyBy('id')
  .value();

console.log(normalized);
// { 1: { id: 1, fullName: 'John Doe', isAdmin: true, ... }, ... }

// Debounced search with safe property access
const searchUsers = _.debounce(async (query) => {
  const results = await fetch(`/api/search?q=${query}`).then(r => r.json());
  const firstCity = _.get(results, 'users[0].address.city', 'N/A');
  console.log(`First result city: ${firstCity}`);
}, 300);

// Functional composition with lodash/fp
import { flow, filter, map, groupBy } from 'lodash/fp';

const processOrders = flow(
  filter(order => order.status === 'completed'),
  map(order => ({ ...order, total: order.quantity * order.price })),
  groupBy('customerId')
);

const orders = [
  { id: 1, customerId: 'c1', status: 'completed', quantity: 2, price: 10 },
  { id: 2, customerId: 'c1', status: 'pending', quantity: 1, price: 20 },
  { id: 3, customerId: 'c2', status: 'completed', quantity: 3, price: 15 }
];

console.log(processOrders(orders));
// { c1: [{ id: 1, total: 20, ... }], c2: [{ id: 3, total: 45, ... }] }

Use Cases

Data normalization in API responses: Use _.mapKeys, _.mapValues, and _.merge to transform inconsistent backend data structures into frontend-ready formats, handling nested objects and array transformations that would require verbose native code.

Form validation and defaulting: Apply _.defaultsDeep to merge user input with default configuration objects recursively, and use _.pickBy or _.omitBy to filter out empty values before submission, ensuring clean data flow.

Debouncing search inputs and event handlers: Implement _.debounce and _.throttle to control function execution frequency in autocomplete components, scroll handlers, or resize events, preventing performance bottlenecks from excessive API calls.

Safe property access in complex objects: Replace fragile chains like user && user.profile && user.profile.address with _.get(user, 'profile.address.city', 'Unknown'), especially when dealing with optional API data or configuration objects.

Functional composition pipelines: Use lodash/fp's auto-curried functions with _.flow or _.pipe to build readable data transformation pipelines, combining operations like filtering, mapping, and grouping without intermediate variables.

Pros & Cons

Pros

+Highly modular architecture supports tree-shaking and per-method imports, allowing bundle sizes from a few KB to full library based on actual usage
+Battle-tested performance optimizations and cross-browser consistency handle edge cases that native methods miss, particularly in deep cloning and object manipulation
+Comprehensive functional programming support through lodash/fp build with immutable, auto-curried, iteratee-first data-last methods
+Extensive documentation with consistent API patterns across 300+ functions makes learning and predicting behavior straightforward
+Production-proven stability in millions of projects reduces risk of bugs compared to implementing complex utilities from scratch

Cons

−Adds external dependency weight when ES6+ native methods can handle simpler use cases like basic array mapping or object spreading
−Development appears stagnant with last significant release in 2019, raising concerns about long-term maintenance and modern JavaScript feature adoption
−Over-reliance can lead to bloated codebases where developers reach for Lodash instead of learning native JavaScript capabilities
−Full library import (common mistake) adds ~24KB minified+gzipped, requiring discipline to use modular imports effectively
−Some methods like _.chain create mutable wrappers that conflict with modern immutable data flow patterns preferred in React/Redux

Comparisons

lodash vs es-toolkit

utility

Install

bash

npm install lodash

bash

pnpm add lodash

bash

bun add lodash

Overview

Quick Start

typescript

import _ from 'lodash';
// Or modular: import debounce from 'lodash/debounce';

// API response transformation
const apiUsers = [
  { id: 1, first_name: 'John', last_name: 'Doe', tags: ['admin', 'active'] },
  { id: 2, first_name: 'Jane', tags: ['active'] },
  { id: 3, first_name: null, last_name: 'Smith', tags: [] }
];

// Clean and transform data
const normalized = _.chain(apiUsers)
  .map(user => ({
    id: user.id,
    fullName: _.compact([user.first_name, user.last_name]).join(' ') || 'Anonymous',
    isAdmin: _.includes(user.tags, 'admin'),
    metadata: _.pick(user, ['tags'])
  }))
  .keyBy('id')
  .value();

console.log(normalized);
// { 1: { id: 1, fullName: 'John Doe', isAdmin: true, ... }, ... }

// Debounced search with safe property access
const searchUsers = _.debounce(async (query) => {
  const results = await fetch(`/api/search?q=${query}`).then(r => r.json());
  const firstCity = _.get(results, 'users[0].address.city', 'N/A');
  console.log(`First result city: ${firstCity}`);
}, 300);

// Functional composition with lodash/fp
import { flow, filter, map, groupBy } from 'lodash/fp';

const processOrders = flow(
  filter(order => order.status === 'completed'),
  map(order => ({ ...order, total: order.quantity * order.price })),
  groupBy('customerId')
);

const orders = [
  { id: 1, customerId: 'c1', status: 'completed', quantity: 2, price: 10 },
  { id: 2, customerId: 'c1', status: 'pending', quantity: 1, price: 20 },
  { id: 3, customerId: 'c2', status: 'completed', quantity: 3, price: 15 }
];

console.log(processOrders(orders));
// { c1: [{ id: 1, total: 20, ... }], c2: [{ id: 3, total: 45, ... }] }

Use Cases

Pros & Cons

Pros

+Highly modular architecture supports tree-shaking and per-method imports, allowing bundle sizes from a few KB to full library based on actual usage
+Battle-tested performance optimizations and cross-browser consistency handle edge cases that native methods miss, particularly in deep cloning and object manipulation
+Comprehensive functional programming support through lodash/fp build with immutable, auto-curried, iteratee-first data-last methods
+Extensive documentation with consistent API patterns across 300+ functions makes learning and predicting behavior straightforward
+Production-proven stability in millions of projects reduces risk of bugs compared to implementing complex utilities from scratch

Cons

−Adds external dependency weight when ES6+ native methods can handle simpler use cases like basic array mapping or object spreading
−Development appears stagnant with last significant release in 2019, raising concerns about long-term maintenance and modern JavaScript feature adoption
−Over-reliance can lead to bloated codebases where developers reach for Lodash instead of learning native JavaScript capabilities
−Full library import (common mistake) adds ~24KB minified+gzipped, requiring discipline to use modular imports effectively
−Some methods like _.chain create mutable wrappers that conflict with modern immutable data flow patterns preferred in React/Redux