Run results for: Object Cloning Performance Benchmark: Spread vs. Object.assign and More

This benchmark tests the performance of various JavaScript methods for cloning or copying objects. Using a randomly generated object, the test compares the efficiency of methods such as the spread syntax and Object.assign. It provides insights into the fastest ways to duplicate large datasets in JavaScript.

Run details:

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

Browser: Chrome 132

Operating system: Mac OS X 10.15.7

Device Platform: Desktop

Date tested: one year ago

Benchmark engine: Benchmark.js

Reference Assignment

211/s

Deep copy using a recursive function

166/s

Spread Syntax

150/s

Object.assign

142/s

JSON

139/s

Object.fromEntries and Object.entries:

107/s

View exact numbers

Test name	Executions per second
✓ Reference Assignment	211 Ops/sec
Deep copy using a recursive function	166 Ops/sec
Spread Syntax	150 Ops/sec
Object.assign	142 Ops/sec
JSON	139 Ops/sec
Object.fromEntries and Object.entries:	107 Ops/sec

Script Preparation code:

function getRandomKey(length = 5) {
    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
    let result = '';
    for (let i = 0; i < length; i++) {
        result += characters.charAt(
            Math.floor(Math.random() * characters.length),
        );
    }
    return result;
}

function getRandomValue() {
    const types = [
        () => Math.random().toString(36).substring(2, 15), // Random string
        () => Math.floor(Math.random() * 1000), // Random number
        () => Math.random() < 0.5, // Random boolean
        () => String.fromCharCode(33 + Math.floor(Math.random() * 94)), // Random symbol
        () => undefined, // undefined
        () => null, // null
        () => (Math.random() < 0.5 ? Symbol('aSymbol') : Symbol()), // Random Symbol
        () => `${Math.floor(Math.random() * 10 ** 15)}n`, // Random BigInt as a string (Note: This won't truly be a BigInt type due to limitations)
    ];
    return types[Math.floor(Math.random() * types.length)]();
}

Tests:

Spread Syntax
const randomObject = {}; const numberOfKeys = 10000; for (let i = 0; i < numberOfKeys; i++) { randomObject[getRandomKey()] = getRandomValue(); } const newObj = {...randomObject};
Object.assign
const randomObject = {}; const numberOfKeys = 10000; for (let i = 0; i < numberOfKeys; i++) { randomObject[getRandomKey()] = getRandomValue(); } const newObj = Object.assign({}, randomObject);
Object.fromEntries and Object.entries:
const randomObject = {}; const numberOfKeys = 10000; for (let i = 0; i < numberOfKeys; i++) { randomObject[getRandomKey()] = getRandomValue(); } const newObj = Object.fromEntries(Object.entries(randomObject));
JSON
const randomObject = {}; const numberOfKeys = 10000; for (let i = 0; i < numberOfKeys; i++) { randomObject[getRandomKey()] = getRandomValue(); } const newObj = JSON.parse(JSON.stringify(randomObject));
Reference Assignment
const randomObject = {}; const numberOfKeys = 10000; for (let i = 0; i < numberOfKeys; i++) { randomObject[getRandomKey()] = getRandomValue(); } const newObj = randomObject;
Deep copy using a recursive function
const randomObject = {}; const numberOfKeys = 10000; for (let i = 0; i < numberOfKeys; i++) { randomObject[getRandomKey()] = getRandomValue(); } function deepCopy(obj) { if (obj === null) return null; if (typeof obj !== "object") return obj; if (obj instanceof Array) return obj.map(deepCopy); const newObj = {}; for (let key in obj) { newObj[key] = deepCopy(obj[key]); } return newObj; } const newObj = deepCopy(randomObject);