Run results for: JSON.stringify vs structuredClone vs simple deepCopyObject 5

Run details:

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36

Browser: Chrome 126

Operating system: Mac OS X 10.15.7

Device Platform: Desktop

Date tested: one year ago

Test name	Executions per second
JSON.stringify	1465515.9 Ops/sec
structuredClone	789100.9 Ops/sec
deepCopyObject	1327544.1 Ops/sec
deepCopyObjectSimple	3476447.8 Ops/sec
deepCopyObjectIterative	3560061.2 Ops/sec
copy	1320249.1 Ops/sec
clone	1245458.5 Ops/sec
copyv2	1523427.1 Ops/sec
JSON.stringify - huge	23.4 Ops/sec
structuredClone - huge	15.8 Ops/sec
deepCopyObject - huge	10.7 Ops/sec
deepCopyObjectSimple - huge	20.5 Ops/sec
deepCopyObjectIterative - huge	21.8 Ops/sec
copy - huge	13.0 Ops/sec
clone - huge	16.7 Ops/sec
copyv2 - huge	13.0 Ops/sec

Script Preparation code:

var 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;
}

var isArray = Array.isArray;

function copy(obj) {
  if (!obj) return obj;
  if (isArray(obj)) {
    var arr = [];
    var length = obj.length;
    for (var i = 0; i < length; i++) arr.push(copy(obj[i]))
    return arr;
  } else if (typeof obj === 'object') {
    var keys = Object.keys(obj);
    var length = keys.length;
    var newObject = {};
    for (var i = 0; i < length; i++) {
      var key = keys[i];
      newObject[key] = copy(obj[key]);
    }
    return newObject;
  }
  return obj;
}

var objectKeys = Object.keys;

function copyv2(val) {
  if (!val) return val;
  if (isArray(val)) {
    var arr = [];
    var length = val.length;
    for (var i = 0; i < length; i++) arr.push(copy(val[i]))
    return arr;
  } else if (typeof val === 'object') {
    var keys = objectKeys(val);
    var newObject = {};
    for (var i = keys.length - 1; i > -1; i--) {
      var 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;
}

var 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;
}

var MyHugeObject = generateNestedObject(7, 5);

var 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);

Run results for: JSON.stringify vs structuredClone vs simple deepCopyObject 5

JSON.stringify vs structuredClone vs simple deepCopyObject 5

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