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

Test name	Executions per second
Spread Syntax	149.5 Ops/sec
Object.assign	142.3 Ops/sec
Object.fromEntries and Object.entries:	106.5 Ops/sec
JSON	139.2 Ops/sec
Reference Assignment	210.9 Ops/sec
Deep copy using a recursive function	165.9 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);

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

Spread Syntax

Object.assign

Object.fromEntries and Object.entries:

JSON

Reference Assignment

Deep copy using a recursive function