Benchmark: compare content of two objects using Object.entries VS for...in

Script Preparation code:

function makeid() {
    var text = "";
    var possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

    for (var i = 0; i < 5; i++)
        text += possible.charAt(Math.floor(Math.random() * possible.length));

    return text;
}

window.parentObj = {};

const samples = 1000;

const a = {};

for (let i = 0; i < samples; i++) {
    a[makeid()] = makeid();
}

const b = JSON.parse(JSON.stringify(a));

const c = {};

for (let i = 0; i < samples; i++) {
    c[makeid()] = makeid();
}

window.parentObj = {a: a, b: b, c: c};

Tests:

Object.entries
const a = window.parentObj.a; const b = window.parentObj.b; const entries = Object.entries(a); const isNotEqual = entries.some(([k, v], i) => b[k] != v); if (isNotEqual) return false; return entries.length === Object.keys(b).length;
Object for..in
const a = window.parentObj.a; const b = window.parentObj.b; for(var key in a) { if (a[key] != b[key]) return false; }; return Object.keys(a).length === Object.keys(b).length;
Object for..in #2
const a = window.parentObj.a; const b = window.parentObj.b; let lengthA = 0; for(var key in a) { lengthA = lengthA + 1; if (a[key] != b[key]) return false; }; return lengthA === Object.keys(b).length;
Object for..in #3
const a = window.parentObj.a; const b = window.parentObj.b; let lengthA = 0; for(var key in a) { lengthA = lengthA + 1; if (a[key] != b[key]) return false; }; let lengthB = 0; for(var key in b) { lengthB = lengthB + 1; }; return lengthA === lengthB;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.entries
Object for..in
Object for..in #2
Object for..in #3

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark compares the performance of three approaches to compare the content of two objects: `Object.entries`, `for...in`, and their variations (`#2` and `#3`). The test creates two large objects, `a` and `b`, with randomly generated keys and values. It then checks if the two objects have equal keys and values.

**Test Options**

1. **Object.entries**: This method returns an array of a given object's own enumerable string-keyed property [key, value] pairs.
2. **for...in**: This loop iterates over the properties (keys) of an object.
3. **Object for...in #2**: Similar to `#1`, but returns the length of the `a` object after iteration.
4. **Object for...in #3**: Compares the lengths of the two objects' keys before and after iteration.

**Pros and Cons**

* **Object.entries**: Fast, concise, and modern way to compare objects. However, it may not be supported in older browsers or Node.js versions.
* **for...in**: Traditional method for iterating over object properties. It is widely supported but can be slower than `Object.entries` due to the overhead of checking property existence.
* **Object for...in #2** and **#3**: These variations are similar to `for...in`, but add an extra step to compare lengths, which can improve performance by reducing the number of iterations.

**Library Used**

None. The benchmark does not use any external libraries, relying on native JavaScript features.

**Special JS Features or Syntax**

* None mentioned in the provided code snippets.

**Benchmark Result Interpretation**

The latest benchmark result shows that:

* `Object.entries` is the fastest approach, with an execution rate of approximately 2186 executions per second.
* The variations of `for...in` (`#2` and `#3`) are slower than `Object.entries`, but closer in performance to each other.

**Alternative Approaches**

Other methods to compare object contents could include:

* Using `JSON.stringify()` and comparing the resulting strings ( slower due to stringification overhead).
* Implementing a custom loop using `Array.prototype.forEach()` or `Array.prototype.reduce()`.
* Utilizing libraries like Lodash or Moment.js for more complex comparisons.

Keep in mind that the choice of approach depends on the specific use case, performance requirements, and browser/Node.js support.

Latest run results:

Run details: (Test run date: 4 years ago)

User agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36

Browser/OS: Chrome 79 on Windows

View result in a separate tab

Test name	Executions per second
Object.entries	2186.4 Ops/sec
Object for..in	4334.8 Ops/sec
Object for..in #2	5610.7 Ops/sec
Object for..in #3	4936.2 Ops/sec

Related benchmarks:

compare content of two objects using Object.entries VS for...in (version: 1)

Comparing performance of: Object.entries vs Object for..in vs Object for..in #2 vs Object for..in #3

Created: 4 years ago by: Registered User

Jump to the latest result

Object.entries

Object for..in

Object for..in #2

Object for..in #3

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):