deepmerge vs underscore vs ramda vs merge-deep vs deepdash vs lodash vs object-path
JavaScript Object Manipulation Libraries
Search packages..
deepmergeunderscoreramdamerge-deepdeepdashlodashobject-pathSimilar Packages:
JavaScript Object Manipulation Libraries

JavaScript Object Manipulation Libraries are tools that provide functions to create, modify, traverse, and manipulate objects and their properties. These libraries offer a wide range of functionalities, such as deep cloning, merging, transforming, and querying objects, making it easier for developers to handle complex data structures in a more efficient and readable manner. They help streamline tasks that involve working with nested objects, arrays, and other data types, providing utility functions that can save time and reduce code complexity. Examples of popular object manipulation libraries include Lodash, Underscore.js, and Ramda, each offering unique features and design philosophies to cater to different programming needs and styles.

Npm Package Weekly Downloads Trend
3 Years
Github Stars Ranking
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
deepmerge37,390,0882,82031.2 kB583 years agoMIT
underscore11,575,46327,384906 kB52a year agoMIT
ramda7,632,27224,1081.2 MB1473 months agoMIT
merge-deep981,564112-145 years agoMIT
deepdash82,078279-275 years agoMIT
lodash061,555-1035 years agoMIT
object-path01,066-354 years agoMIT
Feature Comparison: deepmerge vs underscore vs ramda vs merge-deep vs deepdash vs lodash vs object-path

Deep Merging

  • deepmerge:

    deepmerge specializes in deep merging objects, handling nested properties and arrays with customizable merge strategies. It is designed specifically for merging, making it a reliable choice for this task.

  • underscore:

    underscore offers basic deep merging capabilities through its _.extend and _.merge functions, but it is not as comprehensive or specialized as Lodash or other merging libraries.

  • ramda:

    ramda provides deep merging capabilities through its functional programming approach. It allows for more customizable and composable merging strategies, making it suitable for projects that require a functional style of merging.

  • merge-deep:

    merge-deep provides a simple and efficient implementation of deep merging for objects. It recursively merges properties, making it a lightweight option for projects that need straightforward merging functionality.

  • deepdash:

    deepdash does not provide deep merging capabilities as its primary focus is on deep traversal and manipulation of nested objects and arrays.

  • lodash:

    lodash offers deep merging capabilities through its _.merge function, which recursively merges properties of source objects into a target object. It is versatile and well-optimized for various merging scenarios.

  • object-path:

    object-path does not perform deep merging but allows for deep manipulation of object properties using a path-based approach. It is more focused on getting, setting, and deleting properties at any depth rather than merging.

Deep Traversal

  • deepmerge:

    deepmerge does not provide deep traversal capabilities as it is focused solely on merging objects.

  • underscore:

    underscore offers basic traversal capabilities through functions like _.each, _.map, and _.filter, but it does not specialize in deep traversal or provide any unique features for handling nested structures.

  • ramda:

    ramda provides deep traversal capabilities through its functional programming functions. It allows for composable and immutable traversal of nested data, making it suitable for projects that emphasize functional design.

  • merge-deep:

    merge-deep does not provide deep traversal functionality, as its primary focus is on merging objects.

  • deepdash:

    deepdash excels at deep traversal of nested objects and arrays, allowing you to perform operations like mapping, filtering, and reducing at any depth. It provides a simple API for traversing and manipulating complex data structures.

  • lodash:

    lodash offers deep traversal capabilities through functions like _.forEach, _.map, and _.filter, which can be used recursively on nested objects and arrays. It provides a flexible and efficient way to traverse and manipulate data at any depth.

  • object-path:

    object-path allows for deep traversal of object properties using a path-based syntax. It enables you to access, modify, and delete properties at any depth, making it easy to work with nested structures.

Immutability

  • deepmerge:

    deepmerge does not enforce immutability, but it creates new objects during the merging process, leaving the original objects unchanged.

  • underscore:

    underscore does not enforce immutability, as its functions can modify data in place. However, it provides utility functions that can be used in an immutable manner if the developer chooses to do so.

  • ramda:

    ramda promotes immutability by design, providing pure functions that do not modify the original data. It encourages a functional programming style that avoids side effects and mutable state.

  • merge-deep:

    merge-deep does not enforce immutability, as it modifies the target object during the merging process. However, it does not alter the source objects, keeping them unchanged.

  • deepdash:

    deepdash does not enforce immutability by default, but it allows for immutable operations if implemented by the user during traversal and manipulation.

  • lodash:

    lodash does not enforce immutability, but many of its functions can be used in an immutable manner if the developer chooses to do so. It provides both mutable and immutable operations, giving developers the flexibility to choose.

  • object-path:

    object-path does not enforce immutability, but it allows for immutable operations if the user implements them while manipulating properties. It provides functions that can be used in both mutable and immutable contexts.

Functional Programming Support

  • deepmerge:

    deepmerge is not designed with functional programming in mind, as it focuses on merging objects rather than providing a functional API.

  • underscore:

    underscore supports functional programming concepts, such as higher-order functions, callbacks, and iterators. It provides a solid foundation for functional programming in JavaScript, but it is not as focused on functional purity as Ramda.

  • ramda:

    ramda is a functional programming library that emphasizes immutability, pure functions, and higher-order functions. It is designed to be used in a functional style, making it a great choice for projects that prioritize functional programming principles.

  • merge-deep:

    merge-deep does not provide functional programming features, as it is a simple utility for deep merging objects.

  • deepdash:

    deepdash does not specifically focus on functional programming but can be used in a functional style, especially during deep traversal and manipulation.

  • lodash:

    lodash supports functional programming through its modular design, higher-order functions, and support for currying and composition. It provides many functions that can be used in a functional style, making it versatile for different programming paradigms.

  • object-path:

    object-path does not focus on functional programming but provides a simple API for manipulating object properties that can be used in a functional style.

Ease of Use: Code Examples

  • deepmerge:

    Deep Merging with deepmerge

    import merge from 'deepmerge';

const obj1 = { a: { b: 1 }, c: 3 };
const obj2 = { a: { b: 2 }, c: 4 };

const merged = merge(obj1, obj2);

console.log(merged); // { a: { b: 2 }, c: 4 }
  • underscore:

    Deep Merging with underscore

    import { merge } from 'underscore';

const obj1 = { a: { b: 1 }, c: 3 };
const obj2 = { a: { b: 2 }, c: 4 };

const merged = merge(obj1, obj2);

console.log(merged); // { a: { b: 2 }, c: 4 }
  • ramda:

    Deep Property Manipulation with ramda

    import { set, view, lensPath } from 'ramda';

const obj = { a: { b: { c: 1 } } };
const lens = lensPath(['a', 'b', 'c']);

const updatedObj = set(lens, 2, obj);
console.log(view(lens, updatedObj)); // 2
  • merge-deep:

    Deep Merging with merge-deep

    import mergeDeep from 'merge-deep';

const obj1 = { a: { b: 1 }, c: 3 };
const obj2 = { a: { b: 2 }, c: 4 };

const merged = mergeDeep(obj1, obj2);

console.log(merged); // { a: { b: 2 }, c: 4 }
  • deepdash:

    Deep Traversal with deepdash

    import { deepMap } from 'deepdash';

const obj = { a: { b: { c: 1 } } };

deepMap(obj, (value) => {
  if (typeof value === 'number') {
    return value * 2;
  }
});

console.log(obj); // { a: { b: { c: 2 } } }
  • lodash:

    Deep Merging with lodash

    import { merge } from 'lodash';

const obj1 = { a: { b: 1 }, c: 3 };
const obj2 = { a: { b: 2 }, c: 4 };

const merged = merge(obj1, obj2);

console.log(merged); // { a: { b: 2 }, c: 4 }
  • object-path:

    Deep Property Manipulation with object-path

    import { set, get, del } from 'object-path';

const obj = { a: { b: { c: 1 } } };

set(obj, 'a.b.c', 2);
console.log(get(obj, 'a.b.c')); // 2

del(obj, 'a.b.c');
console.log(get(obj, 'a.b.c')); // undefined
How to Choose: deepmerge vs underscore vs ramda vs merge-deep vs deepdash vs lodash vs object-path
  • deepmerge:

    Select deepmerge when you need a straightforward solution for deep merging objects, especially when dealing with nested properties. It handles merging with customizable strategies for arrays and objects, making it ideal for configuration merging and similar tasks.

  • underscore:

    Choose underscore if you need a lightweight utility library that provides a solid set of functions for object manipulation, similar to Lodash but with a smaller footprint. It is a good choice for projects that require essential utility functions without the need for a comprehensive library.

  • ramda:

    Select ramda if you prefer a functional programming approach to object manipulation. It offers a rich set of curried and composable functions that promote immutability and side-effect-free programming, making it ideal for projects that emphasize functional design principles.

  • merge-deep:

    Use merge-deep if you want a lightweight and simple solution for deep merging objects without any dependencies. It is easy to use and perfect for projects where you need a no-frills merging function without the overhead of a larger library.

  • deepdash:

    Choose deepdash if you need to perform deep operations on nested objects and arrays, such as deep mapping, filtering, or reducing, while maintaining a simple and intuitive API. It is particularly useful for tasks that require traversing and manipulating deeply nested structures.

  • lodash:

    Opt for lodash if you require a comprehensive utility library with a wide range of functions for object manipulation, including deep cloning, merging, and manipulation. It is well-optimized, widely used, and offers a modular approach, allowing you to import only the functions you need.

  • object-path:

    Choose object-path if you need to work with deeply nested object properties using a simple string-based path syntax. It provides functions for getting, setting, deleting, and manipulating properties at any depth, making it great for handling dynamic and uncertain object structures.

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 underscore

underscore is a popular JavaScript utility library that provides a wide range of functions for common programming tasks, including manipulating arrays, objects, and functions. It serves as a foundation for many other libraries and frameworks, offering a functional programming approach to JavaScript development. While underscore is widely used, there are several alternatives that provide similar or enhanced functionality. Here are a few notable alternatives:

  • immutable is a library designed to create immutable data structures in JavaScript. It provides persistent data structures that enable developers to manage state without mutating the original data. This is particularly useful in functional programming and React applications, where immutability can lead to easier state management and improved performance. If your application requires a focus on immutability and you want to avoid side effects from data mutations, immutable is a strong choice.
  • lodash is a modern utility library that builds upon the concepts introduced by underscore, offering a more extensive set of functions and improved performance. It provides a rich set of methods for manipulating arrays, objects, strings, and more, while also supporting chaining and lazy evaluation. If you are looking for a comprehensive utility library with a large community and extensive documentation, lodash is an excellent alternative to underscore.
  • ramda is a functional programming library for JavaScript that emphasizes a point-free style and immutability. It provides a wide range of utility functions that are designed to work seamlessly with functional programming paradigms. If you prefer a more functional approach to programming and want to leverage currying and composition, ramda is a great choice for enhancing your JavaScript code.

To see how underscore compares with immutable, lodash, and ramda, check out the comparison: Comparing immutable vs lodash vs ramda vs underscore.

Similar Npm Packages to ramda

ramda is a functional programming library for JavaScript that emphasizes a declarative approach to coding. It provides a wide array of utility functions that are designed to work seamlessly with JavaScript's built-in data structures. One of the key features of Ramda is its focus on immutability and function composition, allowing developers to create more predictable and maintainable code. While Ramda is a powerful tool for functional programming, there are several alternatives that also provide utility functions for JavaScript development. Here are a few notable options:

  • immutable is a library that provides immutable data structures for JavaScript. It allows developers to work with collections, lists, and maps in an immutable way, which can help prevent unintended side effects in applications. Immutable.js is particularly useful in scenarios where performance and memory efficiency are critical, as it optimizes operations on large data sets. If your application requires a strong emphasis on immutability and performance, Immutable.js is an excellent choice.
  • lodash is a widely-used utility library that provides a rich set of functions for manipulating arrays, objects, and strings. It offers a mix of functional programming features and traditional imperative programming styles, making it versatile for various use cases. Lodash is known for its performance and ease of use, making it a go-to choice for many developers. If you need a comprehensive utility library that balances performance and functionality, Lodash is a solid option.
  • underscore is another utility library that provides a set of functions for common programming tasks, similar to Lodash. While it predates Lodash, it offers a more minimalistic approach to utility functions. Underscore focuses on providing functional programming helpers, but it may not be as feature-rich or performant as Lodash. If you are looking for a lightweight library with essential utility functions, Underscore can be a suitable choice.

To see how Ramda compares with Immutable, Lodash, and Underscore, check out the comparison: Comparing immutable vs lodash vs ramda vs underscore.

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 deepdash

deepdash is a powerful utility library for deep manipulation of JavaScript objects and arrays. It extends the functionality of lodash by providing additional methods specifically designed for deep operations, such as deep merging, deep cloning, and deep searching. This makes it particularly useful for working with complex nested data structures, allowing developers to easily traverse and manipulate data without writing verbose code. While deepdash offers a robust solution for deep data manipulation, there are several alternatives in the JavaScript ecosystem that provide similar functionalities. Here are a few noteworthy alternatives:

  • deepmerge is a simple and effective library for deep merging of objects. It allows developers to combine multiple objects into one while preserving the nested structure. Unlike deepdash, which provides a broader range of deep manipulation functions, deepmerge focuses specifically on the merging aspect, making it a lightweight option for scenarios where deep merging is the primary requirement.

  • lodash is one of the most popular utility libraries in the JavaScript ecosystem. It provides a wide range of functions for manipulating arrays, objects, and other data types. While lodash includes some deep manipulation functions, it is not specifically tailored for deep operations like deepdash. However, its extensive feature set and widespread usage make it a go-to choice for many developers.

  • merge-deep is a minimalistic library that focuses solely on deep merging objects. It is lightweight and straightforward, making it easy to integrate into projects where deep merging is needed without the overhead of a larger utility library. If you only need deep merging capabilities, merge-deep is an excellent choice.

  • object-path is a utility library that provides a way to access and manipulate nested properties in JavaScript objects. It allows developers to get, set, and delete properties at any depth, making it useful for working with deeply nested data structures. While it doesn’t offer the same breadth of functionality as deepdash, it excels in its specific use case of object property manipulation.

  • ramda is a functional programming library for JavaScript that emphasizes a functional programming style. It provides a wide range of utility functions, including those for deep manipulation. Ramda’s focus on immutability and function composition makes it a powerful alternative for developers who prefer a functional approach to data manipulation.

  • underscore is another utility library that provides a variety of functions for working with arrays and objects. Similar to lodash, it includes some deep manipulation capabilities but is not as specialized as deepdash. It is a solid choice for developers looking for a comprehensive utility library, though it may not offer the same depth of functionality for deep operations.

For a detailed comparison of these packages, check out: Comparing deepdash vs deepmerge vs lodash vs merge-deep vs object-path vs ramda vs underscore.

Similar Npm Packages to lodash

lodash is a widely-used utility library in JavaScript that provides a plethora of functions for common programming tasks, such as manipulating arrays, objects, and strings. It simplifies complex tasks and enhances productivity by offering a consistent and performant API. While lodash is a powerful tool for developers, there are several alternatives that also provide utility functions and functional programming capabilities. Here are a few notable alternatives:

  • immutable is a library that provides immutable data structures for JavaScript. It allows developers to work with data in a way that prevents unintended mutations, making it easier to manage state in applications, especially in React. Immutable.js offers persistent data structures that are efficient and can help improve performance in applications that require frequent updates to state. If you are looking for a way to ensure immutability in your data handling, immutable is a strong choice.

  • ramda is a functional programming library for JavaScript that emphasizes a functional programming style. Unlike lodash, which is more focused on utility functions, ramda provides a suite of functions designed to work with functional programming paradigms, such as currying and composition. Ramda's approach allows for more declarative code and can lead to cleaner and more maintainable applications. If you prefer a functional programming style and want to leverage powerful functional utilities, ramda is an excellent alternative.

  • underscore is another utility library that provides a similar set of functions to lodash. It was one of the first utility libraries in JavaScript and laid the groundwork for many of the features that lodash later adopted. While lodash has since become more popular due to its performance optimizations and additional features, underscore remains a solid choice for developers who need basic utility functions without the overhead of a larger library. If you are looking for a lightweight alternative that covers the essentials, underscore may be suitable.

For a detailed comparison of these libraries, check out the following link: Comparing immutable vs lodash vs ramda vs underscore.

Similar Npm Packages to object-path

object-path is a utility library that provides a simple way to access and manipulate nested properties in JavaScript objects. It allows developers to easily get, set, and delete properties using a string path notation, making it particularly useful for working with complex data structures. While object-path is a great tool for handling nested objects, there are several alternatives that offer similar functionality. Here are a few noteworthy options:

  • deepdash is a powerful library that extends the capabilities of lodash to work with deeply nested objects. It provides a set of utilities for traversing, manipulating, and querying deeply nested structures. With features like deep mapping, filtering, and reducing, deepdash is ideal for developers who need to perform complex operations on nested objects. If your application frequently deals with deeply nested data and requires advanced manipulation, deepdash is a strong choice.
  • lodash.get is a utility function from the popular lodash library that allows you to safely access nested properties in an object. It provides a straightforward way to retrieve values without worrying about whether the intermediate properties exist, thus preventing runtime errors. If you are already using lodash in your project, lodash.get is a convenient option for accessing nested properties without adding additional dependencies.
  • lodash.set is another utility function from lodash that enables you to set values at a specified path in a nested object. It allows you to easily update or create properties within complex data structures. If you need to modify nested properties frequently and are already leveraging lodash, lodash.set is an efficient solution that integrates seamlessly with your existing code.

For a comprehensive comparison of these packages, check out this link: Comparing deepdash vs lodash.get vs lodash.set vs object-path.

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, the official website for the npm registry. Note that npm is a registered trademark of npm, Inc. Please share your feedback via our GitHub repository. For more details, please refer to our Terms & Privacy.