deepmerge vs merge-deep vs deep-assign vs assign-deep vs object-assign-deep
Deep Merging and Object Assignment Comparison
Search packages..
1 Year
deepmergemerge-deepdeep-assignassign-deepobject-assign-deepSimilar Packages:
What's Deep Merging and Object Assignment?

Deep merging and object assignment libraries in JavaScript provide functionality to combine multiple objects into one, handling nested properties and arrays. These libraries are useful for tasks like merging configuration objects, combining state in applications, or creating deep copies of objects while preserving their structure. They differ in their approach to handling conflicts, mutability, and performance, making it essential to choose the right one based on your project's needs. For example, deepmerge is known for its robust handling of nested merges and conflicts, while assign-deep focuses on deep assigning properties from source objects to a target object, allowing for more control over the merging process.

Package Weekly Downloads Trend
Github Stars Ranking
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
deepmerge40,245,5552,78131.2 kB542 years agoMIT
merge-deep1,148,880111-144 years agoMIT
deep-assign187,396247-06 years agoMIT
assign-deep59,56278-76 years agoMIT
object-assign-deep27,49271-97 years agoMIT
Feature Comparison: deepmerge vs merge-deep vs deep-assign vs assign-deep vs object-assign-deep

Deep Merging vs. Deep Assigning

  • deepmerge:

    deepmerge specializes in deep merging objects, handling nested properties, arrays, and conflicts. It merges values from multiple sources into a target object, allowing for more complex merging strategies and conflict resolution compared to simple assignment.

  • merge-deep:

    merge-deep provides deep merging functionality, combining properties from multiple objects into one. It handles nested structures and merges values, making it suitable for scenarios where you need to combine multiple objects while preserving their hierarchy.

  • deep-assign:

    deep-assign is similar to assign-deep but emphasizes efficient deep assignment of properties from multiple source objects to a target object. It handles nested properties and ensures that all source values are assigned to the target without merging them.

  • assign-deep:

    assign-deep focuses on deep assigning properties from source objects to a target object, ensuring that nested properties are assigned without overwriting existing values. It does not merge objects but rather assigns values from one or more sources to the target.

  • object-assign-deep:

    object-assign-deep implements deep property assignment, recursively assigning values from source objects to a target object. It mimics the behavior of Object.assign but works at a deeper level, ensuring that nested properties are assigned correctly.

Conflict Resolution

  • deepmerge:

    deepmerge provides advanced conflict resolution by allowing you to define custom merging strategies for different types of values (e.g., arrays, objects). It intelligently merges nested properties and can handle conflicts based on the strategies you configure, making it more flexible and powerful for complex merging scenarios.

  • merge-deep:

    merge-deep resolves conflicts by merging values from multiple objects. If a property exists in both the target and source objects, it merges them based on their types (e.g., arrays are concatenated, objects are merged recursively), providing a more comprehensive approach to handling overlapping properties.

  • deep-assign:

    deep-assign similarly does not resolve conflicts. It assigns values from multiple sources to the target object, with the last source value taking precedence in case of overlapping properties. There is no built-in mechanism for merging conflicting values.

  • assign-deep:

    assign-deep does not handle conflicts since it only assigns values from source objects to the target. If a nested property exists in both the source and target, the value from the source will be assigned, but no merging or conflict resolution occurs.

  • object-assign-deep:

    object-assign-deep does not resolve conflicts; it simply assigns values from source objects to the target. If a nested property exists in both the source and target, the value from the source will overwrite the target's value, similar to the behavior of Object.assign.

Mutability

  • deepmerge:

    deepmerge is immutable by default, meaning it creates a new object with the merged values instead of modifying the original objects. This approach helps prevent side effects and makes the merging process safer, especially in functional programming contexts.

  • merge-deep:

    merge-deep is mutable, as it modifies the target object by merging properties from the source objects. It is important to be aware of this behavior to avoid unintended mutations in your code.

  • deep-assign:

    deep-assign is also mutable, as it directly modifies the target object by assigning properties from the source objects. Care should be taken to avoid mutating objects that are shared across different parts of the application.

  • assign-deep:

    assign-deep is mutable, meaning it modifies the target object directly by assigning values from the source objects. This can lead to unintended side effects if the target object is used elsewhere in the code.

  • object-assign-deep:

    object-assign-deep is mutable, as it modifies the target object by recursively assigning values from the source objects. This can lead to changes in the target object, so it is advisable to use it with caution.

Performance

  • deepmerge:

    deepmerge may have performance overhead due to its comprehensive merging capabilities and support for customizable merging strategies. While it is efficient for most scenarios, the performance can vary depending on the complexity of the objects being merged and the merging strategies used.

  • merge-deep:

    merge-deep is lightweight and performs well for deep merging objects. It is suitable for applications that require quick and efficient merging without the overhead of additional features or complexity.

  • deep-assign:

    deep-assign is designed for efficiency and performs well when deep assigning properties from multiple source objects. Its simplicity and lack of complex merging logic contribute to its fast performance, making it suitable for most use cases.

  • assign-deep:

    assign-deep is performant for deep assigning properties, especially when dealing with a limited number of source objects. However, its performance may degrade with a large number of nested properties or sources due to its recursive nature.

  • object-assign-deep:

    object-assign-deep is efficient for deep assigning properties, especially when working with a small number of source objects. Its performance is comparable to other deep assignment libraries, but it may slow down with highly nested structures.

Ease of Use: Code Examples

  • deepmerge:

    Deep Merging with deepmerge

    const deepmerge = require('deepmerge');

const target = { a: { b: 1, c: [1, 2] }, d: 4 };
const source = { a: { b: 2, c: [3, 4] }, d: 5 };

const merged = deepmerge(target, source);
console.log(merged);
// Output: { a: { b: 2, c: [1, 2, 3, 4] }, d: 5 }
  • merge-deep:

    Deep Merging with merge-deep

    const mergeDeep = require('merge-deep');

const target = { a: { b: 1 }, c: 3 };
const source = { a: { b: 2 }, d: 4 };

const merged = mergeDeep(target, source);
console.log(merged);
// Output: { a: { b: 2 }, c: 3, d: 4 }
  • deep-assign:

    Deep Assigning with deep-assign

    const deepAssign = require('deep-assign');

const target = { a: { b: 1 }, c: 3 };
const source1 = { a: { b: 2 } };
const source2 = { d: 4 };

deepAssign(target, source1, source2);
console.log(target);
// Output: { a: { b: 2 }, c: 3, d: 4 }
  • assign-deep:

    Deep Assigning with assign-deep

    const assignDeep = require('assign-deep');

const target = { a: { b: 1 }, c: 3 };
const source = { a: { b: 2 }, d: 4 };

assignDeep(target, source);
console.log(target);
// Output: { a: { b: 2 }, c: 3, d: 4 }
  • object-assign-deep:

    Deep Assigning with object-assign-deep

    const objectAssignDeep = require('object-assign-deep');

const target = { a: { b: 1 }, c: 3 };
const source = { a: { b: 2 }, d: 4 };

objectAssignDeep(target, source);
console.log(target);
// Output: { a: { b: 2 }, c: 3, d: 4 }
How to Choose: deepmerge vs merge-deep vs deep-assign vs assign-deep vs object-assign-deep
  • deepmerge:

    Opt for deepmerge if you need a comprehensive solution for deep merging objects that handles nested properties, arrays, and conflicts intelligently. It provides customizable merging strategies, making it suitable for complex scenarios where you need fine-grained control over how properties are merged.

  • merge-deep:

    Use merge-deep when you want a lightweight and easy-to-use library for deep merging objects. It is ideal for projects that require a simple merging solution without the overhead of additional features or complexity.

  • deep-assign:

    Select deep-assign if you require a straightforward and efficient way to deep assign properties from multiple source objects to a target object. It is designed for simplicity and performance, making it a good choice for projects where you want to minimize complexity.

  • assign-deep:

    Choose assign-deep if you need a simple and lightweight solution for deep assigning properties from one or more source objects to a target object. It is particularly useful when you want to ensure that nested properties are assigned without overwriting the entire object.

  • object-assign-deep:

    Choose object-assign-deep if you want a straightforward implementation of deep property assignment that mimics the native Object.assign method but works recursively. It is useful for projects that need a clear and concise way to deep assign properties without introducing external dependencies.

Similar Npm Packages to deepmerge

deepmerge is a utility library for merging JavaScript objects deeply. It allows developers to combine nested objects in a way that preserves the structure of both objects, making it especially useful for managing complex state in applications. With deepmerge, you can easily merge configurations, state, or any other nested data structures without losing any information. This library is particularly beneficial when dealing with immutable data structures, as it ensures that the original objects remain unchanged while creating a new merged object.

While deepmerge is a powerful tool, there are other libraries that provide similar functionalities. Here are a couple of alternatives:

  • immer is a popular library that allows developers to work with immutable state in a more convenient way. Instead of merging objects directly, immer uses a concept called "drafts" to enable you to write code that looks like you are mutating the state directly. Under the hood, immer takes care of producing the next immutable state based on your changes. This makes it an excellent choice for applications that require complex state management while maintaining immutability without the boilerplate code often associated with it.
  • lodash.merge is a method from the Lodash library that provides a way to merge objects. Unlike deepmerge, which focuses solely on deep merging, lodash.merge is part of the larger Lodash utility library, which offers a wide range of functions for manipulating arrays, objects, and other data types. Lodash.merge performs a recursive merge of properties, allowing you to combine objects while handling arrays and other data types. If you are already using Lodash in your project, lodash.merge can be a convenient option for merging objects.

To see how deepmerge compares with immer and lodash.merge, check out the comparison: Comparing deepmerge vs immer vs lodash.merge.

Similar Npm Packages to merge-deep

merge-deep is a utility library for merging objects deeply in JavaScript. It allows developers to combine multiple objects into one, ensuring that nested properties are merged correctly rather than overwritten. This is particularly useful when dealing with configuration objects or state management in applications where properties may overlap. While merge-deep provides a straightforward solution for deep merging, there are several alternatives available in the JavaScript ecosystem. Here are a few notable ones:

  • deepmerge is a popular library designed specifically for deep merging objects. It provides a flexible way to merge objects while allowing customization of merge strategies for different data types. deepmerge is particularly useful when you need to handle complex data structures and ensure that nested properties are merged according to specific rules. Its ability to handle arrays and other data types makes it a robust choice for deep merging scenarios.
  • lodash.merge is a method from the well-known Lodash library, which provides a wide range of utility functions for JavaScript. lodash.merge performs a deep merge of two or more objects, combining their properties recursively. If you are already using Lodash in your project, leveraging lodash.merge can be a convenient option, as it integrates seamlessly with other Lodash functions and provides consistent performance.
  • merge is a simple and lightweight library for merging objects. It supports both shallow and deep merging, allowing developers to choose the level of merging they need. While it may not offer as many features as some of the other libraries, its simplicity and ease of use make it a good choice for straightforward merging tasks.
  • merge-options is a utility for merging options objects. It is particularly useful for merging configuration objects where you want to ensure that default values are preserved while allowing for overrides. merge-options provides a simple API for merging objects, making it a great choice for scenarios where you need to combine multiple option objects without deep merging.
  • object-assign-deep is another library that focuses on deep merging objects. It extends the native Object.assign method to support deep merging of nested properties. If you prefer a solution that closely resembles the native JavaScript object manipulation methods, object-assign-deep can be a suitable alternative.

To explore how these libraries compare, check out the following link: Comparing deepmerge vs lodash.merge vs merge vs merge-deep vs merge-options vs object-assign-deep.

Similar Npm Packages to deep-assign

deep-assign is a utility library for merging objects deeply in JavaScript. It allows developers to combine properties from one or more source objects into a target object, ensuring that nested properties are also merged rather than overwritten. This is particularly useful when working with complex data structures where you want to maintain existing values while updating or adding new ones. The library is lightweight and straightforward, making it a popular choice for developers looking for a simple solution to deep object merging.

While deep-assign is a solid choice for deep merging, there are several alternatives available in the JavaScript ecosystem that offer similar functionality:

  • deepmerge is a powerful library specifically designed for deep merging of objects. It provides a more comprehensive set of features compared to deep-assign, including support for arrays and custom merging strategies. If you need a robust solution that can handle complex merging scenarios, deepmerge is an excellent option.
  • lodash.merge is part of the popular Lodash utility library, which provides a wide range of functions for working with arrays, objects, and other data types. The merge function in Lodash allows for deep merging of objects and is widely used in the JavaScript community. If you are already using Lodash in your project, leveraging lodash.merge can be a convenient choice.
  • merge-deep is another utility for deep merging objects. It focuses on simplicity and performance, providing a straightforward API for merging nested properties. If you are looking for a lightweight alternative that still offers deep merging capabilities, merge-deep is worth considering.
  • merge-options is a utility for merging options objects, often used in configuration scenarios. While it is not specifically designed for deep merging, it provides a flexible way to combine options with support for custom merging strategies. If your use case involves merging configuration objects, merge-options can be a suitable choice.
  • object-assign-deep is a simple utility for deep merging objects, similar to deep-assign. It provides a straightforward API for merging properties while maintaining existing values. If you prefer a minimalistic approach to deep merging, object-assign-deep is a viable alternative.

To see how deep-assign compares with these alternatives, check out the comparison: Comparing deep-assign vs deepmerge vs lodash.merge vs merge-deep vs merge-options vs object-assign-deep.

Similar Npm Packages to assign-deep

assign-deep is a utility library for deep merging objects in JavaScript. It allows developers to combine multiple objects into one, ensuring that nested properties are merged rather than overwritten. This is particularly useful when dealing with configuration objects or state management in applications where you need to preserve existing values while updating specific properties. The simplicity and effectiveness of assign-deep make it a popular choice for developers looking to handle deep object assignments seamlessly.

However, there are several alternatives in the ecosystem that also provide deep merging capabilities. Here are a few notable ones:

  • deep-assign is a straightforward library that offers deep merging of objects. Similar to assign-deep, it allows you to merge multiple source objects into a target object, preserving nested properties. deep-assign is lightweight and easy to use, making it a good choice for projects that require basic deep merging functionality without additional overhead.

  • deepmerge is a more feature-rich library that provides deep merging capabilities with additional options for handling arrays and custom merge strategies. It allows developers to define how to merge specific properties, making it suitable for more complex scenarios where you need fine-grained control over the merging process. If your application requires advanced merging logic, deepmerge is an excellent option.

  • merge-deep is another utility for deep merging objects. It focuses on simplicity and performance, providing a straightforward API for merging nested objects. merge-deep is particularly useful for projects that prioritize speed and efficiency while still needing the capability to merge deeply nested structures.

  • object-assign-deep is a utility that extends the native Object.assign method to support deep merging. It allows you to combine multiple objects while preserving nested properties, similar to assign-deep. This library is particularly useful for developers who want to maintain familiarity with the Object.assign syntax while adding deep merging capabilities.

To explore how these libraries compare, check out the comparison: Comparing assign-deep vs deep-assign vs deepmerge vs merge-deep vs object-assign-deep.

Similar Npm Packages to object-assign-deep

object-assign-deep is a utility library that allows for deep merging of objects in JavaScript. It provides a straightforward way to combine properties from one or more source objects into a target object, ensuring that nested objects are merged rather than replaced. This can be particularly useful when you need to update or extend configuration objects, state objects, or any other deeply nested structures without losing existing data.

While object-assign-deep is a solid choice for deep object merging, there are several alternatives in the JavaScript ecosystem that offer similar functionality. Here are a few notable ones:

  • deep-assign is a simple and lightweight utility for deep merging objects. It merges the properties of source objects into a target object recursively, allowing for a straightforward way to combine nested structures. If you are looking for a minimalistic solution without additional features, deep-assign is a great option.
  • deepmerge is a more advanced library for deep merging objects. It provides a flexible merging strategy that can handle arrays and other complex data types. With deepmerge, you can customize how merging is performed, making it suitable for scenarios where you need more control over the merging process. This library is particularly useful when dealing with complex data structures or when you need to define specific merging rules.
  • lodash.merge is part of the popular Lodash utility library, which provides a wide range of functions for working with arrays, objects, and more. The merge function from Lodash performs a deep merge of objects, similar to object-assign-deep, but with the added benefit of being part of a larger library that includes many other useful utilities. If you are already using Lodash in your project, lodash.merge is a convenient choice.
  • merge-deep is another lightweight utility for deep merging objects. It offers a simple API and focuses on performance while ensuring that nested objects are merged correctly. If you need a straightforward solution without the overhead of larger libraries, merge-deep is a solid alternative.

To compare these packages and see which one fits your needs best, check out the comparison: Comparing deep-assign vs deepmerge vs lodash.merge vs merge-deep vs object-assign-deep.

README for deepmerge

deepmerge

Merges the enumerable properties of two or more objects deeply.

UMD bundle is 723B minified+gzipped

Getting Started

Example Usage

const x = {
	foo: { bar: 3 },
	array: [{
		does: 'work',
		too: [ 1, 2, 3 ]
	}]
}

const y = {
	foo: { baz: 4 },
	quux: 5,
	array: [{
		does: 'work',
		too: [ 4, 5, 6 ]
	}, {
		really: 'yes'
	}]
}

const output = {
	foo: {
		bar: 3,
		baz: 4
	},
	array: [{
		does: 'work',
		too: [ 1, 2, 3 ]
	}, {
		does: 'work',
		too: [ 4, 5, 6 ]
	}, {
		really: 'yes'
	}],
	quux: 5
}

merge(x, y) // => output

Installation

With npm do:

npm install deepmerge

deepmerge can be used directly in the browser without the use of package managers/bundlers as well: UMD version from unpkg.com.

Include

deepmerge exposes a CommonJS entry point:

const merge = require('deepmerge')

The ESM entry point was dropped due to a Webpack bug.

API

merge(x, y, [options])

Merge two objects x and y deeply, returning a new merged object with the elements from both x and y.

If an element at the same key is present for both x and y, the value from y will appear in the result.

Merging creates a new object, so that neither x or y is modified.

Note: By default, arrays are merged by concatenating them.

merge.all(arrayOfObjects, [options])

Merges any number of objects into a single result object.

const foobar = { foo: { bar: 3 } }
const foobaz = { foo: { baz: 4 } }
const bar = { bar: 'yay!' }

merge.all([ foobar, foobaz, bar ]) // => { foo: { bar: 3, baz: 4 }, bar: 'yay!' }

Options

arrayMerge

There are multiple ways to merge two arrays, below are a few examples but you can also create your own custom function.

Your arrayMerge function will be called with three arguments: a target array, the source array, and an options object with these properties:

  • isMergeableObject(value)
  • cloneUnlessOtherwiseSpecified(value, options)

arrayMerge example: overwrite target array

Overwrites the existing array values completely rather than concatenating them:

const overwriteMerge = (destinationArray, sourceArray, options) => sourceArray

merge(
	[1, 2, 3],
	[3, 2, 1],
	{ arrayMerge: overwriteMerge }
) // => [3, 2, 1]

arrayMerge example: combine arrays

Combines objects at the same index in the two arrays.

This was the default array merging algorithm pre-version-2.0.0.

const combineMerge = (target, source, options) => {
	const destination = target.slice()

	source.forEach((item, index) => {
		if (typeof destination[index] === 'undefined') {
			destination[index] = options.cloneUnlessOtherwiseSpecified(item, options)
		} else if (options.isMergeableObject(item)) {
			destination[index] = merge(target[index], item, options)
		} else if (target.indexOf(item) === -1) {
			destination.push(item)
		}
	})
	return destination
}

merge(
	[{ a: true }],
	[{ b: true }, 'ah yup'],
	{ arrayMerge: combineMerge }
) // => [{ a: true, b: true }, 'ah yup']

isMergeableObject

By default, deepmerge clones every property from almost every kind of object.

You may not want this, if your objects are of special types, and you want to copy the whole object instead of just copying its properties.

You can accomplish this by passing in a function for the isMergeableObject option.

If you only want to clone properties of plain objects, and ignore all "special" kinds of instantiated objects, you probably want to drop in is-plain-object.

const { isPlainObject } = require('is-plain-object')

function SuperSpecial() {
	this.special = 'oh yeah man totally'
}

const instantiatedSpecialObject = new SuperSpecial()

const target = {
	someProperty: {
		cool: 'oh for sure'
	}
}

const source = {
	someProperty: instantiatedSpecialObject
}

const defaultOutput = merge(target, source)

defaultOutput.someProperty.cool // => 'oh for sure'
defaultOutput.someProperty.special // => 'oh yeah man totally'
defaultOutput.someProperty instanceof SuperSpecial // => false

const customMergeOutput = merge(target, source, {
	isMergeableObject: isPlainObject
})

customMergeOutput.someProperty.cool // => undefined
customMergeOutput.someProperty.special // => 'oh yeah man totally'
customMergeOutput.someProperty instanceof SuperSpecial // => true

customMerge

Specifies a function which can be used to override the default merge behavior for a property, based on the property name.

The customMerge function will be passed the key for each property, and should return the function which should be used to merge the values for that property.

It may also return undefined, in which case the default merge behaviour will be used.

const alex = {
	name: {
		first: 'Alex',
		last: 'Alexson'
	},
	pets: ['Cat', 'Parrot']
}

const tony = {
	name: {
		first: 'Tony',
		last: 'Tonison'
	},
	pets: ['Dog']
}

const mergeNames = (nameA, nameB) => `${nameA.first} and ${nameB.first}`

const options = {
	customMerge: (key) => {
		if (key === 'name') {
			return mergeNames
		}
	}
}

const result = merge(alex, tony, options)

result.name // => 'Alex and Tony'
result.pets // => ['Cat', 'Parrot', 'Dog']

clone

Deprecated.

Defaults to true.

If clone is false then child objects will be copied directly instead of being cloned. This was the default behavior before version 2.x.

Testing

With npm do:

npm test

License

MIT

npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc or npmjs.com, the official website for the npm registry. Please note that npm is a registered trademark of npm, Inc. For more details, please refer to our Terms & Privacy.