Lodash Merge is a powerful method that is used to combine two or more objects, arrays into one. It is similar to the Lodash Assign method, but it has some key differences that make it more powerful in certain situations.

In this article, we will explore what Lodash Merge is and how it can be used.

🔍 If you’re interested in Lodash sorting, check out our previous blog post: Lodash Sort By.

Introduction to Lodash Merge

Lodash has gained immense popularity in the JavaScript community for its comprehensive set of utilities that simplify complex tasks. It aims to make coding more efficient, readable, and maintainable, all while reducing the chances of errors. One standout feature of Lodash is the _.merge function, which enables developers to combine objects and arrays in a seamless manner.

The Role of Lodash Merge

At its core, _.merge plays a crucial role in combining data structures. It allows developers to merge multiple objects and arrays into a single structure, effectively creating a unified result. This is particularly useful when dealing with configuration settings, user profiles, or any scenario that involves aggregating data.

Basics of Merging Objects

Merging Objects at the Top Level

To perform a basic merge of objects using _.merge, simply pass the objects as arguments to the function. The properties of the latter object will overwrite those in the former object in case of conflicts. This ensures that the merged object retains the most recent values.


const object1 = { a: 1, b: 2 };
const object2 = { b: 3, c: 4 };
const mergedObject = _.merge(object1, object2);

// Result: { a: 1, b: 3, c: 4 }

Deep Merging of Objects

In scenarios where you need to merge nested objects, _.merge still shines. The function performs a deep merge, ensuring that properties at all levels are combined harmoniously. This is particularly useful when dealing with complex data structures like nested configurations.


const object1 = { a: { b: 1, c: 2 } };
const object2 = { a: { c: 3, d: 4 } };
const mergedObject = _.merge(object1, object2);

// Result: { a: { b: 1, c: 3, d: 4 } }

Handling Arrays with Lodash Merge

_.merge not only handles objects but also arrays with finesse. When merging arrays, the function concatenates them, ensuring that no data is lost. This is a powerful feature when dealing with data that spans multiple arrays.


const array1 = [1, 2];
const array2 = [3, 4];
const mergedArray = _.merge(array1, array2);

// Result: [1, 2, 3, 4]

Customizing Merge Behavior of Lodash Merge

Using Customizer Functions

In some cases, you might want to customize the merging behavior of _.merge. This is achievable through customizer functions. By providing a customizer function, you gain control over how properties are merged, enabling you to implement complex merging logic tailored to your needs.


const object1 = { a: { b: 1, c: 2 } };
const object2 = { a: { c: 3, d: 4 } };
const mergedObject = _.mergeWith(object1, object2, (objValue, srcValue) => {
  if (_.isArray(objValue)) {
    return objValue.concat(srcValue);

// Result: { a: { b: 1, c: [2, 3], d: 4 } }

Overriding Array Merging

By default, _.merge concatenates arrays. However, if you wish to override this behavior and replace arrays entirely, you can do so by providing a customizer function that handles arrays differently. This level of customization ensures that the function adapts perfectly to your use case.


const object1 = { a: [1, 2] };
const object2 = { a: [3, 4] };

const mergedObject = _.mergeWith(object1, object2, (objValue, srcValue) => {
  if (_.isArray(objValue)) {
    return srcValue; // Override with the second array

// Result: { a: [3, 4] }

The Benefits of Using Lodash Merge

Code Readability and Efficiency

One of the primary advantages of using _.merge is the enhancement of code readability. By utilizing a well-known utility like Lodash, you make your code more understandable for fellow developers. Additionally, _.merge streamlines the merging process, leading to cleaner and more efficient code.

Preventing Overwriting of Data

In scenarios where two objects share similar properties, there’s always a risk of inadvertently overwriting valuable data. _.merge mitigates this risk by ensuring that the latest data is retained during the merging process. This adds a layer of safety and reliability to your code.

Handling Complex Data Structures

Modern applications often deal with intricate data structures. _.merge excels in these situations, offering a seamless way to manage complex objects and arrays. This feature is particularly helpful when dealing with dynamic user inputs or configuration settings.

Practical Examples of Lodash Merge

Merging Configuration Objects

Consider an application that relies on configuration settings. Using _.merge, you can easily combine default settings with user-defined preferences

, ensuring a unified configuration object that respects user choices.


const defaultConfig = { theme: 'light', fontSize: 'medium' };
const userConfig = { fontSize: 'large', showNotifications: true };

const mergedConfig = _.merge(defaultConfig, userConfig);

// Result: { theme: 'light', fontSize: 'large', showNotifications: true }

Updating User Profiles Using Lodash Merge

In social media platforms or user-centric applications, updating user profiles is a common task. By using Lodash Merge you can facilitate the process of updating profile information without losing existing data.


const userProfile = {
  username: 'john_doe',
  bio: 'Web developer',
  social: { twitter: 'johndoe_twitter', linkedin: 'johndoe_linkedin' }

const updatedInfo = {
  bio: 'Full-stack developer',
  social: { github: 'johndoe_github' }

const updatedProfile = _.merge(userProfile, updatedInfo);

// Result: { username: 'john_doe', bio: 'Full-stack developer', social: { twitter: 'johndoe_twitter', linkedin: 'johndoe_linkedin', github: 'johndoe_github' } }

Modifying Nested Settings

Imagine an application with nested settings for different features. _.merge comes to the rescue by allowing you to modify specific settings while leaving the rest untouched. This selective approach simplifies customization.


const appSettings = {
  theme: 'dark',
  features: { notifications: true, analytics: false }

const newSettings = {
  features: { analytics: true }
const customizedSettings = _.merge(appSettings, newSettings);

// Result: { theme: 'dark', features: { notifications: true, analytics: true } }

Best Practices for Using Lodash Merge

Keeping Dependency Management in Check

While Lodash and _.merge offer great utility, it’s crucial to manage dependencies efficiently. Always ensure you are using the latest version of Lodash and keep an eye on any updates or alternatives that might emerge.

Avoiding Unintended Consequences

Though _.merge is powerful, remember that with great power comes great responsibility. Always test your merging scenarios thoroughly to avoid unexpected results. Handle conflicts and edge cases with care to prevent unintended consequences.

Testing and Error Handling

Incorporate comprehensive testing and error handling mechanisms into your codebase. Writing unit tests for merging scenarios and implementing robust error handling ensures the stability and reliability of your application.

Performance Considerations

Evaluating Time and Space Complexity

While _.merge offers convenience, it’s important to consider its performance implications. Deep merging can sometimes lead to increased time complexity, especially for large data structures. Be mindful of these implications and evaluate your application’s needs.

Benchmarks and Optimizations

Benchmarking your code can help you identify bottlenecks and areas for optimization. Explore alternative strategies for merging in specific cases where performance is critical, ensuring that your application remains responsive and efficient.

Alternatives to Lodash Merge

Object Spread and Rest

JavaScript’s object spread and rest syntax can also be used for merging objects and arrays. This approach offers a more concise syntax and is native to the language, reducing the need for external libraries.


const object1 = { a: 1, b: 2 };
const object2 = { b: 3, c: 4 };

const mergedObject = { ...object1, ...object2 };

// Result: { a: 1, b: 3, c: 4 }

Object.assign Method

The Object.assign method is another built-in alternative for merging objects. While it doesn’t handle nested structures as elegantly as Lodash Merge, it’s still a viable option for simpler merging scenarios.


const object1 = { a: 1, b: 2 };
const object2 = { b: 3, c: 4 };

const mergedObject = Object.assign({}, object1, object2);

// Result: { a: 1, b: 3, c: 4 }

Immer Library for Immutability

For applications that prioritize immutability, the Immer library provides a unique approach to managing state updates. It leverages a curried function approach to create modified copies of data, offering an alternative to traditional merging.


import produce from 'immer';

const originalData = { value: 10 };

const updatedData = produce(originalData, draft => {
  draft.value = 20;

// Result: { value: 20 }

Future of Lodash and JavaScript Utilities

As JavaScript continues to evolve, so do its utility libraries. While Lodash remains a valuable tool, stay vigilant for emerging technologies and trends in the JavaScript ecosystem. New utility libraries and language features may reshape how we approach data manipulation in the future.


In the world of JavaScript development, efficient data manipulation is key. Lodash Merge function offers a powerful solution to merging objects and arrays, simplifying the process while maintaining code readability and performance. By understanding the intricacies of _.merge, you empower yourself to create robust applications that handle data with finesse and precision.

For a comprehensive exploration of Lodash’s functionalities, visit the Official Lodash Documentation.


1. Is Lodash the only utility library available for JavaScript?

No, there are several utility libraries available, each with its own set of features and advantages. Some alternatives include Underscore.js and Ramda.

2. Can I use Lodash Merge to combine arrays with different lengths?

Yes, _.merge can merge arrays of different lengths by concatenating them together.

3. Does using Lodash Merge impact the performance of my application?

While _.merge is efficient for most scenarios, deep merging can lead to increased time complexity.

4. Is it possible to merge objects with circular references using _.merge?

No, _.merge does not handle circular references well. It’s important to avoid circular structures when using this function.

5. Can I use Lodash Merge in a Node.js environment?

Yes, _.merge is compatible with both browser and Node.js environments. Just ensure you have Lodash properly integrated into your project.

Categorized in:

Tagged in: