Benchmark: JSON.stringify vs structuredClone vs simple deepCopyObject 512

JSON.stringify vs structuredClone vs simple deepCopyObject 512 (version: 0)

JSON.stringify vs structuredClone vs simple deepCopyObject 512

Comparing performance of: JSON.stringify vs structuredClone vs deepCopyObject vs deepCopyObjectSimple vs deepCopyObjectIterative vs copy vs clone vs copyv2 vs JSON.stringify - huge vs structuredClone - huge vs deepCopyObject - huge vs deepCopyObjectSimple - huge vs deepCopyObjectIterative - huge vs copy - huge vs clone - huge vs copyv2 - huge

Created: one month ago by: Guest

Jump to the latest result

Script Preparation code:

let deepCopyObject = (inObject) => {
if (inObject instanceof Date) return inObject

if (inObject instanceof Set) return new Set(inObject)

if (inObject instanceof Map) return new Map(inObject)

if (typeof inObject !== 'object' || inObject === null) {
return inObject // Return the value if inObject is not an object
}

// Create an array or object to hold the values
const outObject = Array.isArray(inObject) ? [] : {}

Object.keys(inObject).forEach((key) => {
const value = inObject[key]

    // Recursively (deep) copy for nested objects, including arrays
    outObject[key] = typeof value === 'object' && value !== null ? deepCopyObject(value) : value
})

return outObject
}

function deepCopyObjectSimple(inObject) {
if (typeof inObject !== 'object' || inObject === null) {
return inObject;
}

const outObject = Array.isArray(inObject) ? [] : {};

for (const key in inObject) {
const value = inObject[key];
outObject[key] = (typeof value === 'object' && value !== null) ? deepCopyObjectSimple(value) : value;
}

return outObject;
}

let isArray = Array.isArray;

function copy(obj) {
if (!obj) return obj;
if (isArray(obj)) {
let arr = [];
let length = obj.length;
for (let i = 0; i < length; i++) arr.push(copy(obj[i]))
return arr;
} else if (typeof obj === 'object') {
let keys = Object.keys(obj);
let length = keys.length;
let newObject = {};
for (let i = 0; i < length; i++) {
let key = keys[i];
newObject[key] = copy(obj[key]);
}
return newObject;
}
return obj;
}

let objectKeys = Object.keys;

function copyv2(val) {
if (!val) return val;
if (isArray(val)) {
let arr = [];
let length = val.length;
for (let i = 0; i < length; i++) arr.push(copy(val[i]))
return arr;
} else if (typeof val === 'object') {
let keys = objectKeys(val);
let newObject = {};
for (let i = keys.length - 1; i > -1; i--) {
let key = keys[i];
newObject[key] = copy(val[key]);
}
return newObject;
}
return val;
}


function cloneRegExp(re) {
const regexMatch = /^\/(.*)\/([gimyu]*)$/.exec(re.toString());
return new RegExp(regexMatch[1], regexMatch[2]);
}

function clone(arg) {
if (typeof arg !== 'object') {
return arg;
}
if (arg === null) {
return null;
}
if (Array.isArray(arg)) {
return arg.map(clone);
}
const cloned = {};
for (const name in arg) {
if (Object.prototype.hasOwnProperty.call(arg, name)) {
(cloned)[name] = clone(
(arg)[name],
);
}
}
return cloned;
}


function deepCopyObjectIterative(inObject) {
if (typeof inObject !== 'object' || inObject === null) {
return inObject;
}

const stack = [{ source: inObject, target: Array.isArray(inObject) ? [] : {} }];
const root = stack[0].target;

while (stack.length > 0) {
const { source, target } = stack.pop();

    for (const key in source) {
      const value = source[key];
      if (typeof value === 'object' && value !== null) {
        target[key] = Array.isArray(value) ? [] : {};
        stack.push({ source: value, target: target[key] });
      } else {
        target[key] = value;
      }
    }
}

return root;
}

let MyObject = {
description: 'Creates a deep copy of source, which should be an object or an array.',
myNumber: 123456789,
myBoolean: true,
jayson: {
stringify: 'JSON.stringify() method converts a JavaScript value to a JSON string....',
parse: 'JSON.parse() method parses a JSON string...'
}
};

function generateNestedObject(depth, breadth) {
if (depth === 0) {
return 'end'; // Base value at the deepest level
}

let result = {};
for (let i = 0; i < breadth; i++) {
result[`key${i}`] = {
value: `value${depth}-${i}`,
nestedArray: Array.from({ length: breadth }, (_, k) => `item${depth}-${i}-${k}`),
nestedObject: generateNestedObject(depth - 1, breadth)
};
}
return result;
}

let MyHugeObject = generateNestedObject(7, 5);

let myCopy = null;

Tests:

JSON.stringify
myCopy = JSON.parse(JSON.stringify(MyObject));
structuredClone
myCopy = structuredClone(MyObject);
deepCopyObject
myCopy = deepCopyObject(MyObject);
deepCopyObjectSimple
myCopy = deepCopyObjectSimple(MyObject);
deepCopyObjectIterative
myCopy = deepCopyObjectIterative(MyObject);
copy
myCopy = copy(MyObject);
clone
myCopy = clone(MyObject);
copyv2
myCopy = copyv2(MyObject);
JSON.stringify - huge
myCopy = JSON.parse(JSON.stringify(MyHugeObject));
structuredClone - huge
myCopy = structuredClone(MyHugeObject);
deepCopyObject - huge
myCopy = deepCopyObject(MyHugeObject);
deepCopyObjectSimple - huge
myCopy = deepCopyObjectSimple(MyHugeObject);
deepCopyObjectIterative - huge
myCopy = deepCopyObjectIterative(MyHugeObject);
copy - huge
myCopy = copy(MyHugeObject);
clone - huge
myCopy = clone(MyHugeObject);
copyv2 - huge
myCopy = copyv2(MyHugeObject);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
JSON.stringify
structuredClone
deepCopyObject
deepCopyObjectSimple
deepCopyObjectIterative
copy
clone
copyv2
JSON.stringify - huge
structuredClone - huge
deepCopyObject - huge
deepCopyObjectSimple - huge
deepCopyObjectIterative - huge
copy - huge
clone - huge
copyv2 - huge

Fastest: N/A

Slowest: N/A

ⓘ Get performance results from real users on your website with Request Metrics.

Website Performance Monitoring by Request Metrics

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

JSON.stringify vs structuredClone vs simple deepCopyObject 512 (version: 0)

JSON.stringify vs structuredClone vs simple deepCopyObject 512

Created: one month ago by: Guest

Jump to the latest result

JSON.stringify

structuredClone

deepCopyObject

deepCopyObjectSimple

deepCopyObjectIterative

copy

clone

copyv2

JSON.stringify - huge

structuredClone - huge

deepCopyObject - huge

deepCopyObjectSimple - huge

deepCopyObjectIterative - huge

copy - huge

clone - huge

copyv2 - huge

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

No previous run results