Benchmark: fastMerge alternatives

Onyx fastmerge

const ONYX_INTERNALS__REPLACE_OBJECT_MARK = 'ONYX_INTERNALS__REPLACE_OBJECT_MARK';

function fastMergeOriginal(target, source, options, metadata, basePath = []) {
    if (!metadata) {
        metadata = {
            replaceNullPatches: [],
        };
    }

    if (Array.isArray(source) || source === null || source === undefined) {
        return {result: source, replaceNullPatches: metadata.replaceNullPatches};
    }

    const optionsWithDefaults = {
        shouldRemoveNestedNulls: options?.shouldRemoveNestedNulls ?? false,
        objectRemovalMode: options?.objectRemovalMode ?? 'none',
    };

    const mergedValue = mergeObjectOriginal(target, source, optionsWithDefaults, metadata, basePath);
    return {result: mergedValue, replaceNullPatches: metadata.replaceNullPatches};
}

function mergeObjectOriginal(target, source, options, metadata, basePath) {
    const destination = {};
    const targetObject = isMergeableObjectOriginal(target) ? target : undefined;

    if (targetObject) {
        Object.keys(targetObject).forEach((key) => {
            const targetProperty = targetObject?.[key];
            const sourceProperty = source?.[key];

            const shouldOmitNullishProperty = options.shouldRemoveNestedNulls && (targetProperty === null || sourceProperty === null);

            if (targetProperty === undefined || shouldOmitNullishProperty) {
                return;
            }

            destination[key] = targetProperty;
        });
    }

    Object.keys(source).forEach((key) => {
        let targetProperty = targetObject?.[key];
        const sourceProperty = source[key];

        const shouldOmitNullishProperty = options.shouldRemoveNestedNulls && sourceProperty === null;

        if (sourceProperty === undefined || shouldOmitNullishProperty) {
            return;
        }

        if (!isMergeableObjectOriginal(sourceProperty)) {
            destination[key] = sourceProperty;
            return;
        }

        if (options.objectRemovalMode === 'mark' && targetProperty === null) {
            targetProperty = {[ONYX_INTERNALS__REPLACE_OBJECT_MARK]: true};
            metadata.replaceNullPatches.push([[...basePath, key], {...sourceProperty}]);
        }

        if (options.objectRemovalMode === 'replace' && sourceProperty[ONYX_INTERNALS__REPLACE_OBJECT_MARK]) {
            const sourcePropertyWithoutMark = {...sourceProperty};
            delete sourcePropertyWithoutMark.ONYX_INTERNALS__REPLACE_OBJECT_MARK;
            destination[key] = sourcePropertyWithoutMark;
            return;
        }

        destination[key] = fastMergeOriginal(targetProperty, sourceProperty, options, metadata, [...basePath, key]).result;
    });

    return destination;
}

function isMergeableObjectOriginal(value) {
    const isNonNullObject = value != null ? typeof value === 'object' : false;
    return isNonNullObject && !(value instanceof RegExp) && !(value instanceof Date) && !Array.isArray(value);
}

const data1 = generateDeepObject(5, 3);
const data2 = generateDeepObject(5, 3);

// Test
fastMergeOriginal(data1, data2, { shouldRemoveNestedNulls: true });

Optimized fastMerge

function fastMergeOptimized(target, source, options, metadata = { replaceNullPatches: [] }, basePath = []) {
    if (source === null || source === undefined || Array.isArray(source)) {
        return { result: source, replaceNullPatches: metadata.replaceNullPatches };
    }

    const optionsWithDefaults = {
        shouldRemoveNestedNulls: options?.shouldRemoveNestedNulls ?? false,
        objectRemovalMode: options?.objectRemovalMode ?? 'none',
    };

    const mergedValue = mergeObjectOptimized(target, source, optionsWithDefaults, metadata, basePath);
    return { result: mergedValue, replaceNullPatches: metadata.replaceNullPatches };
}

function mergeObjectOptimized(target, source, options, metadata, basePath) {
    const destination = Object.create(null);
    const targetObject = isMergeableObjectOptimized(target) ? target : undefined;
    const { shouldRemoveNestedNulls, objectRemovalMode } = options;

    if (targetObject) {
        const targetKeys = Object.keys(targetObject);
        for (let i = 0; i < targetKeys.length; i++) {
            const key = targetKeys[i];
            const targetProperty = targetObject[key];
            const sourceProperty = source[key];

            const shouldOmit = shouldRemoveNestedNulls && (targetProperty === null || sourceProperty === null);

            if (targetProperty !== undefined && !shouldOmit) {
                destination[key] = targetProperty;
            }
        }
    }

    const sourceKeys = Object.keys(source);
    for (let i = 0; i < sourceKeys.length; i++) {
        const key = sourceKeys[i];
        let targetProperty = targetObject?.[key];
        const sourceProperty = source[key];

        if (sourceProperty === undefined) continue;
        
        const shouldOmitNullish = shouldRemoveNestedNulls && sourceProperty === null;
        if (shouldOmitNullish) continue;

        if (!isMergeableObjectOptimized(sourceProperty)) {
            destination[key] = sourceProperty;
            continue;
        }

        if (objectRemovalMode === 'mark' && targetProperty === null) {
            targetProperty = { [ONYX_INTERNALS__REPLACE_OBJECT_MARK]: true };
            metadata.replaceNullPatches.push([basePath.concat(key), { ...sourceProperty }]);
        }

        if (objectRemovalMode === 'replace' && sourceProperty[ONYX_INTERNALS__REPLACE_OBJECT_MARK]) {
            const { [ONYX_INTERNALS__REPLACE_OBJECT_MARK]: _, ...cleanSource } = sourceProperty;
            destination[key] = cleanSource;
            continue;
        }

        const newPath = basePath.length === 0 ? [key] : basePath.concat(key);
        destination[key] = fastMergeOptimized(targetProperty, sourceProperty, options, metadata, newPath).result;
    }

    return destination;
}

const objectCtorString = Object.prototype.constructor.toString();
function isMergeableObjectOptimized(value) {
    if (value === null || typeof value !== 'object') return false;
    
    const proto = Object.getPrototypeOf(value);
    if (proto === null) return true;
    
    return proto.constructor && proto.constructor.toString() === objectCtorString;
}

const data1 = generateDeepObject(5, 3);
const data2 = generateDeepObject(5, 3);

// Test
fastMergeOptimized(data1, data2, { shouldRemoveNestedNulls: true });

ImmerJs

const data1 = generateDeepObject(5, 3);
const data2 = generateDeepObject(5, 3);

// Test
immer.produce(data1, draft => {
    Object.assign(draft, data2);
});

Loadash-es

const data1 = generateDeepObject(5, 3);
const data2 = generateDeepObject(5, 3);

// Test  
_.merge(_.cloneDeep(data1), data2);

Test name	Executions per second
✓ ImmerJs	4,678 Ops/sec
Onyx fastmerge	3,186 Ops/sec
Optimized fastMerge	2,253 Ops/sec
Loadash-es	1,264 Ops/sec

fastMerge alternatives (version: 1)

Logic analysis over fastMerge() implementation versus other libraries

Comparing performance of: `Onyx fastmerge vs Optimized fastMerge vs ImmerJs vs Loadash-es`

Created: 10 months ago by: Registered User

Go to the latest result

Onyx fastmerge

Optimized fastMerge

ImmerJs

Loadash-es

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

fastMerge alternatives (version: 1)

Logic analysis over fastMerge() implementation versus other libraries

Comparing performance of: Onyx fastmerge vs Optimized fastMerge vs ImmerJs vs Loadash-es

Created: 10 months ago by: Registered User

Go to the latest result

Onyx fastmerge

Optimized fastMerge

ImmerJs

Loadash-es

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Related benchmarks

Comparing performance of: `Onyx fastmerge vs Optimized fastMerge vs ImmerJs vs Loadash-es`