Run results for: new Recursive Clone VS other Cloning Methods

Run details:

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36

Browser: Chrome 116

Operating system: Linux

Device Platform: Desktop

Date tested: one year ago

Test name	Executions per second
Lodash cloneDeep	231973.1 Ops/sec
JSON parse	228410.0 Ops/sec
For loop	238612.4 Ops/sec
Recursive clone deep	464329.9 Ops/sec
Recursive reduce clone deep	133374.6 Ops/sec
altClone	361491.7 Ops/sec
structured	108949.8 Ops/sec

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

var obj = {
    a: "hello",
    c: "test",
    num: 3,
    arr: [1, 2, 3, 4],
    anotherObj: {
        a: 35,
        str: "tester"
    }
};

function altClone(obj) {
    if (obj) {
        let clone;
        const isNested = (item) => typeof item === 'object';
        if (Array.isArray(obj)) {
            clone = [];
            obj.forEach((value) => {
                clone.push(isNested(value) ? deepClone(value) : value);
            });
        } else {
            clone = {};
            Object.keys(obj).forEach((key) => {
                const value = obj[key];
                clone[key] = isNested(value) ? deepClone(value) : value;
            });
        }
        return clone;
    }
    return obj;
};

var deepClone = function(obj) {
    var out = null;

    if (Array.isArray(obj)) {
        out = [];
        for (var index = 0; index < obj.length; ++index) {
            var subArray = obj[index];
            out.push((typeof subArray === 'object') ? deepClone(subArray) : subArray);
        }
    } else {
        out = {};
        for (var key in obj) {
            var subObject = obj[key];
            out[key] = (typeof subObject === 'object') ? deepClone(subObject) : subObject;
        }
    }
    return out;
};

function structured(value) {
    return window.structuredClone(value)
}

function cloneArray(value) {
    var newArray;
    if (value && value.length) {
        newArray = [];
        for (var i = 0; i < value.length; i++) {
            if (typeof value[i] === 'object') {
                newArray[i] = Array.isArray(value[i]) ? cloneArray(value[i]) : cloneObject(value[i]);
            } else {
                newArray[i] = value[i];
            }
        }
    } else if (value === null) {
        newArray = null;
    }
    return newArray;
}

function cloneObject(value) {
    var newObject;
    if (value && typeof value === 'object' && Object.keys(value).length > 0) {
        newObject = {};
        for (var key in value) {
            if (typeof value[key] === 'object') {
                newObject[key] = Array.isArray(value) ? cloneArray(value[key]) : cloneObject(value[key]);
            } else {
                newObject[key] = value[key];
            }
        }
    } else if (value && typeof value === 'object' && Object.keys(value).length === 0) {
        newObject = {};
    } else if (value === null) {
        newObject = null;
    }
    return newObject;
}

function reduceDeepClone(obj) {
    return Object.keys(obj).reduce((v, d) => Object.assign(v, {
        [d]: (obj[d].constructor === Object) ? reduceDeepClone(obj[d]) : obj[d]
    }), {});
}

Tests:

Lodash cloneDeep
testCopy = _.cloneDeep(obj);
JSON parse
testCopy = JSON.parse(JSON.stringify(obj));
For loop
testCopy = cloneObject(obj);
Recursive clone deep
testCopy = deepClone(obj);
Recursive reduce clone deep
testCopy = reduceDeepClone(obj);
altClone
testCopy = altClone(obj);
structured
testCopy = structured(obj);

Run results for: new Recursive Clone VS other Cloning Methods

compare object deep copy/clone methods

Lodash cloneDeep

JSON parse

For loop

Recursive clone deep

Recursive reduce clone deep

altClone

structured