@fastify/deepmerge

Merges the enumerable properties of two or more objects deeply. Fastest implementation of deepmerge, see section 'Benchmarks'.

Install

npm i @fastify/deepmerge

Usage

The module exports a function, which provides a function to deepmerge Objects.

@fastify/deepmerge does not mutate the input objects. It returns a new object, which is the result of the merge.

deepmerge(options)

options is optional and can contain the following values:

• symbols (boolean, optional) - should also merge object keys that are symbols, default is false
• all (boolean, optional) - makes deepmerge accept and merge any number of passed objects, default is false
• mergeArray (function, optional) - provide a function, which returns a function to add custom array merging function
• cloneProtoObject (function, optional) - provide a function, which must return a clone of the object with the prototype of the object
• isMergeableObject (function, optional) - provide a function, which must return true if the object should be merged, default is isMergeableObject from this module

1const deepmerge = require('@fastify/deepmerge')()
2const result = deepmerge({a: 'value'}, { b: 404 })
3console.log(result) // {a: 'value',  b: 404 }

1const deepmerge = require('@fastify/deepmerge')({ all: true })
2const result = deepmerge({a: 'value'}, { b: 404 }, { a: 404 })
3console.log(result) // {a: 404,  b: 404 }

mergeArray

The default mode to merge Arrays is to concat the source-Array to the target-Array.

1const target = [1, 2, 3]
2const source = [4, 5, 6]
3const deepmerge = require('@fastify/deepmerge')()
4const result = deepmerge(target, source)
5console.log(result) // [1, 2, 3, 4, 5, 6]

To overwrite the default behavior regarding merging Arrays, you can provide a function to the mergeArray option of the deepmerge-function. The function provided to mergeArray gets an options-parameter passed, which is an Object containing the following keys and values.

1clone: (value: any) => any;
2isMergeableObject: (value: any) => any;
3deepmerge: DeepMergeFn;
4getKeys: (value: object) => string[];

The mergeArray-Function needs to return the actual Array merging function, which accepts two parameters of type Array, and returns a value.

Example 1: Replace the target-Array with a clone of the source-Array.

1function replaceByClonedSource(options) {
2  const clone = options.clone
3  return function (target, source) {
4    return clone(source)
5  }
6}
7
8const deepmerge = require('@fastify/deepmerge')({ mergeArray: replaceByClonedSource })
9const result = deepmerge([1, 2, 3], [4, 5, 6])
10console.log(result) // [4, 5, 6]

Example 2: Merge each element of the source-Array with the element at the same index-position of the target-Array.

1function deepmergeArray(options) {
2  const deepmerge = options.deepmerge
3  const clone = options.clone
4  return function (target, source) {
5    let i = 0
6    const tl = target.length
7    const sl = source.length
8    const il = Math.max(target.length, source.length)
9    const result = new Array(il)
10    for (i = 0; i < il; ++i) {
11      if (i < sl) {
12        result[i] = deepmerge(target[i], source[i])
13      } else {
14        result[i] = clone(target[i])
15      }
16    }
17    return result
18  }
19}
20
21// default behavior
22const deepmergeConcatArray = require('@fastify/deepmerge')()
23const resultConcatArray = deepmergeConcatArray([{ a: [1, 2, 3 ]}], [{b: [4, 5, 6]}])
24console.log(resultConcatArray) // [ { a: [ 1, 2, 3 ]}, { b: [ 4, 5, 6 ] } ]
25
26// modified behavior
27const deepmergeDeepmergeArray = require('@fastify/deepmerge')({ mergeArray: deepmergeArray })
28const resultDeepmergedArray = deepmergeDeepmergeArray([{ a: [1, 2, 3 ]}], [{b: [4, 5, 6]}])
29console.log(resultDeepmergedArray) // [ { a: [ 1, 2, 3 ], b: [ 4, 5, 6 ] } ]

cloneProtoObject

Merging objects with prototypes, such as Streams or Buffers, are not supported by default. You can provide a custom function to let this module deal with the object that has a prototype (JSON object excluded).

1function cloneByReference (source) {
2  return source
3}
4
5const deepmergeByReference = require('@fastify/deepmerge')({
6  cloneProtoObject: cloneByReference
7})
8
9const result = deepmergeByReference({}, { stream: process.stdout })
10console.log(result) // { stream: <ref *1> WriteStream }

isMergeableObject

By default, @fastify/deepmerge merges all objects except native Date and RegExp objects. To exclude certain objects from being merged, you can provide a custom function to the isMergeableObject option.

The default function is exported by this module as isMergeableObject.

The following example shows how to extend the default function to exclude globally defined FormData objects from being identified as mergeable objects.

1const { isMergeableObject: defaultIsMergeableObject } = require('@fastify/deepmerge')
2
3
4function customIsMergeableObject (source) {
5  return defaultIsMergeableObject(source) && !(source instanceof FormData)
6}
7
8const deepmergeWithCustomMergeableObject = require('@fastify/deepmerge')({
9  isMergeableObject: customIsMergeableObject
10})

Benchmarks

The benchmarks are available in the benchmark folder.

npm run bench - benchmark various use cases of deepmerge:

@fastify/deepmerge: merge regex with date x 1,256,523,040 ops/sec ±0.16% (92 runs sampled)
@fastify/deepmerge: merge object with a primitive x 1,256,082,915 ops/sec ±0.25% (97 runs sampled)
@fastify/deepmerge: merge two arrays containing strings x 25,392,605 ops/sec ±0.22% (97 runs sampled)
@fastify/deepmerge: two merge arrays containing objects x 1,655,426 ops/sec ±0.65% (96 runs sampled)
@fastify/deepmerge: merge two flat objects x 15,571,029 ops/sec ±0.45% (96 runs sampled)
@fastify/deepmerge: merge nested objects x 7,601,328 ops/sec ±0.31% (96 runs sampled)

npm run bench:compare - comparison of @fastify/deepmerge with other popular deepmerge implementation:

@fastify/deepmerge x 605,343 ops/sec ±0.87% (96 runs sampled)
deepmerge x 20,312 ops/sec ±1.06% (92 runs sampled)
merge-deep x 83,167 ops/sec ±1.30% (94 runs sampled)
ts-deepmerge x 175,977 ops/sec ±0.57% (96 runs sampled)
deepmerge-ts x 174,973 ops/sec ±0.44% (93 runs sampled)
lodash.merge x 89,213 ops/sec ±0.70% (98 runs sampled)

License

Licensed under MIT.