deepdash, deepmerge, lodash, merge-deep, object-path, ramda, and underscore are all JavaScript utility libraries that help developers work with objects, especially when dealing with deeply nested data structures. These packages provide functions for tasks like deep merging objects, safely accessing nested properties, and transforming complex data. While some are general-purpose utility belts (lodash, underscore, ramda), others focus on specific problems like deep merging (deepmerge, merge-deep) or path-based object access (object-path). deepdash extends Lodash with deep versions of many of its methods. Professional frontend teams choose among these based on their project's architectural style, immutability requirements, and whether they prefer functional programming paradigms or more traditional utility approaches.
Deep Object Manipulation in JavaScript: A Practical Guide to Popular Utilities
When building complex frontend applications, you often need to work with deeply nested objects — merging configurations, updating nested state, or traversing data structures. The JavaScript ecosystem offers several mature libraries for these tasks, each with distinct philosophies and trade-offs. Let’s compare deepdash, deepmerge, lodash, merge-deep, object-path, ramda, and underscore through the lens of real-world engineering scenarios.
🧩 Core Capabilities: What Each Library Actually Does
Deep Merging Objects
deepmerge is purpose-built for deep object merging with predictable behavior.
import deepmerge from 'deepmerge';
const target = { a: { b: 1 } };
const source = { a: { c: 2 } };
const result = deepmerge(target, source);
// { a: { b: 1, c: 2 } }
lodash provides _.merge() for deep merging, but it mutates the first argument by default (unless you clone it first).
import _ from 'lodash';
const target = { a: { b: 1 } };
const source = { a: { c: 2 } };
const result = _.merge({}, target, source); // Note: {} as first arg to avoid mutation
// { a: { b: 1, c: 2 } }
merge-deep offers a simple, immutable deep merge API.
import mergeDeep from 'merge-deep';
const target = { a: { b: 1 } };
const source = { a: { c: 2 } };
const result = mergeDeep(target, source);
// { a: { b: 1, c: 2 } }
ramda doesn’t include deep merge out of the box, but you can combine R.mergeDeepWith with custom logic.
import * as R from 'ramda';
const target = { a: { b: 1 } };
const source = { a: { c: 2 } };
const result = R.mergeDeepRight(target, source);
// { a: { b: 1, c: 2 } }
underscore has no built-in deep merge — you’d need to implement it manually or use shallow _.extend().
import _ from 'underscore';
const target = { a: { b: 1 } };
const source = { a: { c: 2 } };
const result = _.extend({}, target, source); // Shallow only!
// { a: { c: 2 } } — overwrites entire 'a' property
deepdash extends Lodash with deep versions of many methods, including deep merge.
import _ from 'lodash';
import deepdash from 'deepdash';
const _ = deepdash(_);
const target = { a: { b: 1 } };
const source = { a: { c: 2 } };
const result = _.mergeDeep(target, source);
// { a: { b: 1, c: 2 } }
object-path focuses on path-based access, not merging — so it’s not applicable here.
Accessing Nested Properties Safely
object-path excels at safe, path-based property access.
import objectPath from 'object-path';
const obj = { a: { b: { c: 42 } } };
const value = objectPath.get(obj, 'a.b.c');
// 42
const missing = objectPath.get(obj, 'a.x.y', 'default');
// 'default'
lodash provides _.get() for similar functionality.
import _ from 'lodash';
const obj = { a: { b: { c: 42 } } };
const value = _.get(obj, 'a.b.c');
// 42
const missing = _.get(obj, 'a.x.y', 'default');
// 'default'
ramda uses R.path() for this purpose.
import * as R from 'ramda';
const obj = { a: { b: { c: 42 } } };
const value = R.path(['a', 'b', 'c'], obj);
// 42
const missing = R.pathOr('default', ['a', 'x', 'y'], obj);
// 'default'
underscore has no built-in path access — you’d need to chain _.property() or write custom logic.
import _ from 'underscore';
const obj = { a: { b: { c: 42 } } };
// No direct equivalent — requires manual implementation
deepdash, deepmerge, and merge-deep don’t focus on property access, so they lack this feature.
Functional Programming Style vs Utility Belt
ramda is built around functional programming principles: immutable, curried functions that compose well.
import * as R from 'ramda';
const transform = R.pipe(
R.assoc('timestamp', Date.now()),
R.evolve({ count: R.inc })
);
transform({ count: 5 }); // { count: 6, timestamp: 1717020000000 }
lodash and underscore offer a more imperative, utility-belt approach — useful for one-off operations but less composable.
import _ from 'lodash';
const data = { count: 5 };
const transformed = _.assign({}, data, { timestamp: Date.now() });
transformed.count = _.increment(transformed.count); // Note: no _.increment — just example
deepdash enhances Lodash with deep versions of many methods (mapValuesDeep, omitDeep, etc.), making it powerful for nested data transformation.
import _ from 'lodash';
import deepdash from 'deepdash';
const _ = deepdash(_);
const obj = { a: { b: 1, c: null }, d: { e: 2 } };
const cleaned = _.omitDeep(obj, _.isNull);
// { a: { b: 1 }, d: { e: 2 } }
⚙️ Mutation vs Immutability
This is a critical distinction in modern frontend development, especially with React and Redux.
lodash: Many methods (like_.merge()) mutate the first argument unless you pass an empty object as the first parameter.deepmerge: Always returns a new object — fully immutable.merge-deep: Also immutable by design.ramda: All functions are immutable and never mutate inputs.underscore: Generally mutable (e.g.,_.extend()modifies the first object).deepdash: Follows Lodash’s mutation patterns unless using explicitly immutable variants.object-path: Immutable for reads;set()returns a new object by default (can mutate if you pass{ mutable: true }).
📦 Bundle Size and Scope
While we’re not quoting numbers, consider the scope:
deepmergeandmerge-deepare tiny, single-purpose libraries.object-pathis also minimal and focused.lodashandunderscoreare large utility belts — you’ll likely import only what you need via tree-shaking.ramdais a full FP library — powerful but broad.deepdashis an extension of Lodash, so it adds to Lodash’s footprint.
🛠️ Real-World Decision Guide
Scenario 1: You Need Simple, Reliable Deep Merging
If your only need is deep object merging (e.g., combining config objects), deepmerge is the gold standard — battle-tested, immutable, and zero surprises.
Scenario 2: You’re Already Using Lodash
If you’re already using Lodash for other utilities, lodash’s _.merge() (with an empty initial object) is convenient. If you need deep versions of other Lodash methods (like map, omit, etc.), add deepdash.
Scenario 3: You Prefer Functional Programming
If your codebase embraces FP principles, ramda gives you composable, immutable tools — including mergeDeepRight and path.
Scenario 4: You Frequently Access Nested Properties
For frequent safe access to nested properties (e.g., in form handling or API response parsing), object-path or lodash’s _.get() are excellent choices.
Scenario 5: You’re Working on a Legacy Project
underscore is still found in older codebases, but it lacks modern features like deep merging and safe path access. Avoid it in new projects.
🔄 Key Trade-offs Summarized
| Library | Deep Merge | Safe Path Access | Immutability | FP-Friendly | Best For |
|---|---|---|---|---|---|
deepmerge | ✅ Excellent | ❌ | ✅ | ❌ | Pure deep merging |
merge-deep | ✅ Good | ❌ | ✅ | ❌ | Simple deep merging |
lodash | ✅ (with caveats) | ✅ (_.get) | ❌ (mutable by default) | ❌ | General utility work |
deepdash | ✅ (extends Lodash) | ❌ | ❌ | ❌ | Deep Lodash operations |
object-path | ❌ | ✅ Excellent | ✅ (by default) | ❌ | Nested property access |
ramda | ✅ (mergeDeepRight) | ✅ (path) | ✅ | ✅ | Functional programming |
underscore | ❌ | ❌ | ❌ | ❌ | Legacy projects only |
💡 Final Recommendation
- For deep merging only: Choose
deepmerge— it’s the most reliable and widely adopted. - For mixed utility needs: Use
lodashwith careful attention to mutation, orramdaif you prefer FP. - For nested property access:
object-pathorlodash.getare both solid. - Avoid
underscorein new projects — it hasn’t kept pace with modern JavaScript patterns. - Consider
deepdashonly if you’re heavily invested in Lodash and need deep versions of many methods.
Remember: the best library is the one that matches your team’s style, project constraints, and long-term maintainability goals. Don’t add dependencies you don’t need — sometimes a small utility function is better than a full library.
- lodash:
Choose
lodashif you need a comprehensive utility library that covers a wide range of operations beyond just deep object manipulation. Its_.merge()and_.get()methods handle common deep object tasks, though you must remember to pass an empty object as the first argument to_.merge()to avoid mutation. Lodash is well-suited for projects that require diverse utility functions and benefit from tree-shaking to minimize bundle impact. - deepmerge:
Choose
deepmergeif your primary need is reliable, immutable deep object merging with predictable behavior. It's the most widely adopted solution for this specific problem and handles edge cases like arrays, dates, and custom merge strategies well. It's ideal for configuration merging, state updates, or any scenario where you need to combine nested objects without side effects. - underscore:
Choose
underscoreonly if you're maintaining a legacy codebase that already depends on it. It lacks modern features like deep merging and safe nested property access, and its API feels dated compared to alternatives. For new projects, preferlodash(which was inspired by Underscore but is more actively maintained and feature-rich) or more specialized libraries based on your specific needs. - ramda:
Choose
ramdaif your codebase embraces functional programming principles and you need immutable, composable functions for working with objects. ItsmergeDeepRight,path, andpathOrfunctions handle deep merging and property access elegantly, and everything composes well with other Ramda utilities. It's ideal for teams comfortable with FP concepts who want to avoid mutation entirely and build pipelines of data transformations. - merge-deep:
Choose
merge-deepif you want a lightweight, immutable alternative todeepmergewith a simpler API. It's good for basic deep merging scenarios where you don't need advanced customization options like custom merge strategies. However, it's less battle-tested thandeepmergeand may not handle as many edge cases, so evaluate carefully for production-critical merging logic. - deepdash:
Choose
deepdashif you're already using Lodash and need deep versions of Lodash methods likemapValues,omit, orpickthat work recursively on nested objects. It's particularly useful when you have complex nested data transformations that go beyond simple merging. However, be aware that it inherits Lodash's mutation behavior unless you explicitly use immutable variants, and it adds to your bundle size on top of Lodash itself. - object-path:
Choose
object-pathif your main challenge is safely accessing, setting, or deleting deeply nested properties using string paths. It excels at scenarios like form handling, dynamic configuration, or working with API responses where you need to read/write nested values without worrying about undefined intermediate properties. It's not suitable for deep merging or complex transformations, but it's excellent for its specific purpose.
lodash v4.17.23
The Lodash library exported as Node.js modules.
Installation
Using npm:
$ npm i -g npm
$ npm i --save lodash
In Node.js:
// Load the full build.
var _ = require('lodash');
// Load the core build.
var _ = require('lodash/core');
// Load the FP build for immutable auto-curried iteratee-first data-last methods.
var fp = require('lodash/fp');
// Load method categories.
var array = require('lodash/array');
var object = require('lodash/fp/object');
// Cherry-pick methods for smaller browserify/rollup/webpack bundles.
var at = require('lodash/at');
var curryN = require('lodash/fp/curryN');
See the package source for more details.
Note:
Install n_ for Lodash use in the Node.js < 6 REPL.
Support
Tested in Chrome 74-75, Firefox 66-67, IE 11, Edge 18, Safari 11-12, & Node.js 8-12.
Automated browser & CI test runs are available.