Benchmark: Merge Deep Array

HTML Preparation code:

<script src='https://unpkg.com/deepmerge/dist/umd.js'></script>

Script Preparation code:

var arr = [{
    de: {
        product: {
            'test.a.label': 'Beispiel A',
            'test.a.body': 'Blindtext A',
        },
        override: {
            'test.a.override': 'Überschrieben A',
        },
    },
    en: {
        product: {
            'test.a.label': 'Example A',
            'test.a.body': 'Lorem Ipsum A',
        },
        override: {
            'test.a.override': 'Override A',
        },
    },
}, {
    de: {
        product: {
            'test.b.label': 'Beispiel B',
            'test.b.body': 'Blindtext B',
        },
        override: {
            'test.b.override': 'Überschrieben B',
        },
    },
    en: {
        product: {
            'test.b.label': 'Example B',
            'test.b.body': 'Lorem Ipsum B',
        },
        override: {
            'test.b.override': 'Override B',
        },
    },
}, {
    de: {
        product: {
            'test.single-language.label': 'Beispiel einzelne Sprache',
            'test.single-language.body': 'Blindtext für einzelene Sprache',
        },
        override: {
            'test.single-language.override': 'Überschrieben einzelene Sprache',
        },
    },
}, {
    de: {
        product: {
            'test.single-namespace.label': 'Beispiel Single Namespace',
        },
    },
    en: {
        product: {
            'test.single-namespace.label': 'Example Single Namespace',
        },
    },
}, {}, {
    de: {},
    en: {},
}];

function deepMerge(obj1, obj2) {
    for (const key of Object.keys(obj2)) {
        if (obj2[key] instanceof Object && obj1[key] instanceof Object) {
            obj1[key] = deepMerge(obj1[key], obj2[key]);
        } else {
            obj1[key] = obj2[key];
        }
    }

    return obj1;
}

function deepMergeWithSpread(obj1, obj2) {
    const result = {
        ...obj1
    };

    for (const key of Object.keys(obj2)) {
        if (obj2[key] instanceof Object && obj1[key] instanceof Object) {
            result[key] = deepMergeWithSpread(obj1[key], obj2[key]);
        } else {
            result[key] = obj2[key];
        }
    }

    return result;
}

function mergeLocalizedAndNamespacedTranslationRecord(target, source) {
    const result = {
        ...target
    };
    Object.keys(source).forEach((locale) => {
        if (!(locale in target)) {
            result[locale] = source[locale];
        } else {
            result[locale] = mergeNamespacedTranslationRecords(target[locale], source[locale]);
        }
    });

    return result;
}

function mergeNamespacedTranslationRecords(target, source) {
    const result = {
        ...target
    };
    Object.keys(source).forEach((namespace) => {
        if (!(namespace in target)) {
            result[namespace] = source[namespace];
        } else {
            result[namespace] = mergeSimpleRecords(target[namespace], source[namespace]);
        }
    });

    return result;
}

function mergeSimpleRecords(target, source) {
    const result = {
        ...target
    };
    Object.keys(source).forEach((key) => {
        result[key] = source[key];
    });

    return result;
}

Tests:

deepMerge
deepMerge(arr[0], arr[1]);
deepMergeWithSpread
deepMergeWithSpread(arr[0], arr[1]);
Library deepmerge
deepmerge(arr[0], arr[1]);
mergeLocalizedAndNamespacedTranslationRecord
mergeLocalizedAndNamespacedTranslationRecord(arr[0], arr[1]);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
deepMerge
deepMergeWithSpread
Library deepmerge
mergeLocalizedAndNamespacedTranslationRecord

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark and explain what's being tested, compared, and their pros and cons.

**Benchmark Definition:**

The benchmark measures how long it takes to merge two arrays of deeply nested objects of the same shape. The merging is done in three different ways:

1. `deepMerge(arr[0], arr[1])`: This implementation recursively merges the two arrays by iterating over the keys of one array and checking if both objects have the same key. If so, it calls itself with the corresponding nested objects.
2. `deepMergeWithSpread(arr[0], arr[1])`: This implementation uses the spread operator (`...`) to create a new object that contains all properties from both arrays. It then recursively merges any nested objects found in either array.
3. The third benchmark, "Library deepmerge", uses an external library called deepmerge, which provides a more efficient and standardized way of merging objects.

**Comparison:**

The comparison is done by executing each benchmark on the same input data (`arr[0]` and `arr[1]`) multiple times (not explicitly stated in the provided information) and measuring the execution time. The test name indicates which implementation is being tested.

**Pros and Cons:**

* **deepMerge(arr[0], arr[1])**:
	+ Pros: Simple to understand, no external dependencies.
	+ Cons: Recursion can lead to stack overflows for very deep objects, and it's not as efficient as other methods.
* **deepMergeWithSpread(arr[0], arr[1])**:
	+ Pros: More efficient than the recursive implementation, doesn't require recursion limits.
	+ Cons: Uses more memory, especially for large datasets, since it creates a new object with all properties from both arrays.
* **Library deepmerge**:
	+ Pros: Standardized and optimized for performance, reduces code duplication.
	+ Cons: External dependency, may have licensing or compatibility issues.

The latest benchmark results show that the `deepMergeWithSpread` implementation is faster than the recursive `deepMerge` implementation, while the library-based approach is even more efficient. However, it's essential to consider the trade-offs between performance, memory usage, and code complexity when choosing an implementation.

Latest run results:

Run details: (Test run date: 3 months ago)

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 17_5_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 17 on iOS 17.5.1

View result in a separate tab

Test name	Executions per second
deepMerge	596912.5 Ops/sec
deepMergeWithSpread	475206.9 Ops/sec
Library deepmerge	320982.5 Ops/sec
mergeLocalizedAndNamespacedTranslationRecord	650790.0 Ops/sec

Related benchmarks:

Merge Deep Array (version: 0)

Merge an array of deeply nested objects of the same shape.

Comparing performance of: deepMerge vs deepMergeWithSpread vs Library deepmerge vs mergeLocalizedAndNamespacedTranslationRecord

Created: 3 months ago by: Guest

Jump to the latest result

deepMerge

deepMergeWithSpread

Library deepmerge

mergeLocalizedAndNamespacedTranslationRecord

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):