Lodash ES

Lodash ES is the Lodash utility library exported as ES6 modules, providing 300+ utility functions for common programming tasks. It offers modular imports for better tree-shaking, enabling modern JavaScript applications to import only the specific utilities they need, reducing bundle size while maintaining the full power and consistency of the Lodash API.

Package Information

• Package Name: lodash-es
• Package Type: npm
• Language: JavaScript (ES6 modules)
• Installation: npm install lodash-es

Core Imports

import { map, filter, reduce, cloneDeep } from "lodash-es";

You can also import individual functions:

import map from "lodash-es/map.js";
import filter from "lodash-es/filter.js";

For category imports:

import * as array from "lodash-es/array.js";
import * as collection from "lodash-es/collection.js";

For the complete lodash instance (not recommended for production due to bundle size):

import _ from "lodash-es";

Basic Usage

import { map, filter, groupBy, cloneDeep } from "lodash-es";

const users = [
  { name: "Alice", age: 25, active: true, department: "engineering" },
  { name: "Bob", age: 30, active: false, department: "sales" },
  { name: "Charlie", age: 35, active: true, department: "engineering" }
];

// Transform data
const activeUserNames = map(
  filter(users, "active"),
  "name"
); // ["Alice", "Charlie"]

// Group data
const usersByDepartment = groupBy(users, "department");
/* {
  engineering: [Alice, Charlie],
  sales: [Bob]
} */

// Deep clone objects
const usersCopy = cloneDeep(users);

Architecture

Lodash ES is organized around several key concepts:

• Modular Design: Each function is available as a separate ES6 module for optimal tree-shaking
• Category Organization: Functions are grouped into logical categories (Array, Collection, Object, etc.)
• Iteratee Shorthand: Many functions support string, object, and array shorthand for iteratees
• Chain Support: Full chaining support via the main lodash instance
• Type Coercion: Consistent type handling and conversion patterns across all functions

Capabilities

Array Manipulation

Comprehensive array utilities for creation, modification, and analysis including chunking, flattening, set operations, and element manipulation.

function chunk(array, size);
function compact(array);
function difference(array, ...values);
function drop(array, n);
function flatten(array);
function uniq(array);

Array Functions

Collection Operations

Iteration and transformation utilities that work with arrays, objects, and other collections, including mapping, filtering, reducing, and grouping operations.

function map(collection, iteratee);
function filter(collection, predicate);
function reduce(collection, iteratee, accumulator);
function groupBy(collection, iteratee);
function every(collection, predicate);
function some(collection, predicate);

Collection Functions

Object Utilities

Object manipulation functions for property access, modification, merging, and transformation including deep operations and property path handling.

function get(object, path, defaultValue);
function set(object, path, value);
function merge(object, ...sources);
function pick(object, ...paths);
function omit(object, ...paths);
function keys(object);

Object Functions

String Processing

String manipulation utilities for case conversion, trimming, templating, and text processing operations.

function camelCase(string);
function kebabCase(string);
function snakeCase(string);
function capitalize(string);
function trim(string, chars);
function template(string, options);

String Functions

Function Utilities

Function composition, decoration, and control flow utilities including debouncing, throttling, currying, and memoization.

function debounce(func, wait, options);
function throttle(func, wait, options);
function curry(func, arity);
function memoize(func, resolver);
function bind(func, thisArg, ...partials);
function once(func);

Function Functions

Type Checking

Comprehensive type checking utilities for validating data types, including primitives, objects, arrays, and special types.

function isArray(value);
function isObject(value);
function isString(value);
function isNumber(value);
function isFunction(value);
function isEmpty(value);

Type Checking Functions

Mathematical Operations

Mathematical utilities for arithmetic operations, rounding, and statistical calculations.

function add(augend, addend);
function subtract(minuend, subtrahend);
function multiply(multiplier, multiplicand);
function divide(dividend, divisor);
function sum(array);
function mean(array);

Math Functions

Number Utilities

Number manipulation utilities for clamping, range checking, and random number generation.

function clamp(number, lower, upper);
function inRange(number, start, end);
function random(lower, upper, floating);

Number Functions

Utility Functions

General utility functions for common programming patterns including identity, constant functions, flow control, and stub functions.

function identity(value);
function constant(value);
function noop();
function flow(...funcs);
function times(n, iteratee);
function uniqueId(prefix);

Utility Functions

Sequence/Chain Operations

Chain operations that enable method chaining and lazy evaluation for complex data transformation pipelines.

function chain(value);

Sequence Functions

Date Operations

Date and time utilities for timestamp operations.

function now();

Date Functions

Common Patterns

Iteratee Shorthand

Many lodash functions accept iteratee shorthand:

// Function iteratee
map(users, user => user.name);

// Property string shorthand
map(users, 'name');

// Object match shorthand
filter(users, { active: true });

// Property-value pair shorthand
filter(users, ['active', true]);

Chaining

import _ from "lodash-es";

const result = _(users)
  .filter('active')
  .map('name')
  .sort()
  .value();

Error Handling

• Invalid iteratees default to identity function
• Invalid paths return undefined
• Type checking functions return false for invalid types
• Math functions may return NaN for invalid inputs

Performance Notes

• Use named imports for better tree-shaking: import { map } from "lodash-es"
• Individual function imports minimize bundle size: import map from "lodash-es/map.js"
• Functions are optimized for both performance and memory usage
• Chain operations support lazy evaluation for better performance