Skip to content Skip to footer

Merging Objects in JavaScript: A Deep Dive

Hey there, fellow coders! Today, we’re going to tackle the concept of merging objects in JavaScript. Whether you’re building a simple web app or wrestling with a complex frontend project, understanding how to effectively combine objects is a must-have skill in your developer toolbox. So, let’s dive right in and explore the various ways to merge objects, and when to use each one.

The Basics: Object.assign

When it comes to merging objects in vanilla JavaScript, Object.assign is your bread and butter. This method is perfect for shallow merging, which means it only considers the object’s own enumerable properties. Nested objects? They’re gonna require a bit more finesse, but we’ll get to that.

Here’s a quick example to show you Object.assign in action:

const styleSettings = { color: 'blue', fontSize: '14px' };
const additionalSettings = { fontWeight: 'bold', color: 'red' };

const mergedSettings = Object.assign({}, styleSettings, additionalSettings);

// Output: { color: 'red', fontSize: '14px', fontWeight: 'bold' }

Notice how the color property from additionalSettings overwrites the one from styleSettings? That’s because with Object.assign, the last source’s properties will overwrite the previous ones if they have the same key.

Spread Operator: The Modern Twist

ES6 brought us the spread operator ..., and it made merging objects a breeze in a more readable and concise way. It’s like giving your code a breath of fresh air, don’t you think? Here’s how you can use the spread operator to merge objects:

const baseConfig = { env: 'production', debug: false };
const overrideConfig = { debug: true, version: '1.2.0' };

const finalConfig = { ...baseConfig, ...overrideConfig };

// Output: { env: 'production', debug: true, version: '1.2.0' }

Similar to Object.assign, the spread operator performs a shallow merge, and properties from the second object will take precedence.

Deep Merging: Lodash to the Rescue

When you have a nested object structure, shallow merging won’t cut it. You’ll end up with references to the same nested objects, which can lead to some pretty pesky bugs. That’s where Lodash, a utility library that’s like a Swiss Army knife for JavaScript, comes in handy. Its _.merge function is designed for deep merging.

First, make sure you’ve got Lodash in your project. If not, just run npm install lodash or add it to your project from Lodash on NPM.

Now, let’s merge some nested objects:

const _ = require('lodash');

const userProfiles = {
  johnDoe: { likes: ['coding', 'pizza'], age: 28 },
  janeSmith: { likes: ['travel', 'photography'], age: 34 }

const newInfo = {
  johnDoe: { likes: ['gaming'], age: 29 },
  janeSmith: { likes: ['baking'] }

const updatedProfiles = _.merge({}, userProfiles, newInfo);

// Output:
// {
//   johnDoe: { likes: ['coding', 'pizza', 'gaming'], age: 29 },
//   janeSmith: { likes: ['travel', 'photography', 'baking'], age: 34 }
// }

Lodash’s _.merge does the heavy lifting, seamlessly combining the nested arrays and updating the values without breaking a sweat.

Immutable Merging with Immer

For those of you who are into the whole immutability thing (React developers, I’m looking at you), meet Immer. It’s a tiny package that allows you to work with immutable state in a more convenient way. You can find Immer on GitHub or install it via npm install immer.

Let’s take a look at how you can use Immer to merge objects:

import produce from 'immer';

const initialState = { theme: 'dark', layout: 'grid' };
const updates = { theme: 'light', sidebar: true };

const nextState = produce(initialState, draft => {
  Object.assign(draft, updates);

// Output: { theme: 'light', layout: 'grid', sidebar: true }

With Immer, you work on a draft state, and once you’re done, it produces the next immutable state for you. Neat, right?

Alright, folks! That’s the first half of our journey into merging objects in JavaScript. We’ve covered the basics with Object.assign, the elegance of the spread operator, the depth of Lodash, and the immutability of Immer. Stay tuned for the second half where we’ll dive into more advanced scenarios and tackle any edge cases that might pop up. Happy coding until then!

Handling Edge Cases: When Merging Gets Tricky

Welcome back! As we continue our deep dive into JavaScript object merging, let’s turn our attention to edge cases. It’s all fun and games until you encounter properties that are not plain objects or you need to handle array concatenation in a special way. Let’s explore how we can gracefully handle these situations.

Customizing Merge Behavior with Lodash

Lodash is more than just a one-trick pony. With its _.mergeWith function, you can customize the merging behavior by providing a customizer function. This can be particularly useful when you want to control how arrays or certain objects are merged.

Here’s an example where we concatenate arrays instead of merging or overwriting them:

const _ = require('lodash');

const defaultOptions = {
  plugins: ['plugin1', 'plugin2'],
  settings: { theme: 'dark' }

const userOptions = {
  plugins: ['plugin3'],
  settings: { theme: 'light' }

function customizer(objValue, srcValue) {
  if (_.isArray(objValue)) {
    return objValue.concat(srcValue);

const mergedOptions = _.mergeWith({}, defaultOptions, userOptions, customizer);

// Output: { plugins: ['plugin1', 'plugin2', 'plugin3'], settings: { theme: 'light' } }

In this example, the customizer function checks if the property value is an array and, if so, concatenates the values instead of overwriting them.

Preserving Property Types

Sometimes you need to ensure that the type of the properties remains consistent when merging. For instance, you might want to avoid merging an array into an object or vice versa. This requires a bit more logic in your merging strategy:

function typeSafeMerger(target, source) {
  Object.keys(source).forEach(key => {
    if (typeof target[key] === 'undefined') {
      target[key] = source[key];
    } else if (typeof target[key] === typeof source[key]) {
      if (typeof target[key] === 'object' && !Array.isArray(target[key])) {
        typeSafeMerger(target[key], source[key]);
      } else {
        target[key] = source[key];
    } else {
      console.warn(`Type mismatch for property ${key}; skipping merge.`);
  return target;

const objA = { count: 5, settings: { theme: 'dark' } };
const objB = { count: [10], settings: 'user-preferences' };

const safeMerge = typeSafeMerger({}, objA, objB);

// Output: { count: 5, settings: { theme: 'dark' } }
// Warning: Type mismatch for property count; skipping merge.
// Warning: Type mismatch for property settings; skipping merge.

In this typeSafeMerger function, we’re being cautious and only merging properties when their types match, otherwise, we log a warning and skip the merge for that property.

ES6 Modules and Tree Shaking

When working with modern JavaScript frameworks and build tools, you might want to avoid importing the entire Lodash library for the sake of tree shaking and keeping your bundle sizes small. Luckily, Lodash provides modular packages:

import mergeWith from 'lodash/mergeWith';

// Use mergeWith as shown in previous examples

By importing only the functions you need, you can help your bundler eliminate unused code, leading to smaller and faster-loading applications.


And there you have it, a comprehensive guide to merging objects in JavaScript. We’ve seen how to handle the basics with Object.assign and the spread operator, how to delve into deep merges with Lodash, and how to keep your state immutable with Immer. We’ve also tackled custom merge behaviors and preserving property types to ensure your merges are as clean and bug-free as possible.

Remember, the key to effective object merging lies in understanding the data structures you’re working with and choosing the right tool for the job. Whether you’re dealing with simple configurations or complex state management, JavaScript has got you covered with a plethora of options for merging objects.

Now, go forth and merge with confidence, knowing that you have the knowledge and tools to handle whatever object-related challenges come your way. Happy coding!