Benchmark: Object.entries vs for of

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.parentArr = [];

for (let i = 0; i < 100; i++) {
	window.parentArr.push(makeid());
}

Tests:

entries
const newObj = {}; for (const [i, v] of window.parentArr.entries()) { if ((i % 2) === 0) { newObj[i] = v; } }
for
const newObj = {}; for (let i = 0; i < window.parentArr.length; i++) { if ((i % 2) === 0) { newObj[i] = window.parentArr[i]; } }
foreach
const newObj = {}; window.parentArr.forEach((v, i) => { if ((i % 2) === 0) { newObj[i] = v; } })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
entries
for
foreach

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 115 on Windows

View result in a separate tab

Test name	Executions per second
entries	509806.3 Ops/sec
for	37739.6 Ops/sec
foreach	696596.3 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its various components.

**Benchmark Definition**

The benchmark is defined by a JSON object that contains several key pieces of information:

* `Name`: The name of the benchmark, which in this case is "Object.entries vs for".
* `Description`: A brief description of the benchmark (empty in this case).
* `Script Preparation Code` and `Html Preparation Code`: These are code snippets that are executed before running each test case.

The script preparation code generates an array of 100 random IDs using a function called `makeid()`. This array is stored in the `window.parentArr` variable. The script also initializes an empty object to store the results (`const newObj = {};`).

**Test Cases**

There are three test cases:

1. `entries`: Tests the `Object.entries()` method to iterate over an array.
2. `for`: Tests a traditional `for` loop to iterate over an array.
3. `foreach`: Tests the `forEach()` method to iterate over an array.

Each test case has a similar structure, where an object (`newObj`) is created and then populated with values from the `window.parentArr` array using one of the iteration methods.

**Library Usage**

None of the test cases explicitly use any external libraries. However, the `forEach()` method in the third test case uses a built-in JavaScript function, which is a part of the ECMAScript standard (not a library).

**Special JS Features/Syntax**

The benchmark does not explicitly use any special JavaScript features or syntax beyond what's typically available.

**Options Being Compared**

The main options being compared are:

* `Object.entries()`: Iterates over an array using the `entries()` method, which returns an iterator of key-value pairs.
* Traditional `for` loop: Iterates over an array using a traditional `for` loop with indexing (`i`).
* `forEach()`: Iterates over an array using the `forEach()` method, which executes a callback function for each element in the array.

**Pros and Cons of Each Approach**

Here are some pros and cons of each approach:

1. **Object.entries()**:
	* Pros: Efficient iteration, handles arrays with non-numeric keys, can be faster due to native implementation.
	* Cons: May not work as expected if the iterator is not properly configured, requires JavaScript 12+ for support.
2. Traditional `for` loop:
	* Pros: Wide compatibility across browsers and versions, easy to understand and implement.
	* Cons: Can be slower than other methods due to indexing and looping overhead.
3. `forEach()`:
	* Pros: Easy to use, widely supported in modern browsers, can handle arrays with non-numeric keys.
	* Cons: May not work as expected if the callback function is not properly configured, can be slower than other methods due to function call overhead.

**Other Alternatives**

If you want to test different iteration methods or alternatives, some options could include:

* `map()`: Iterates over an array using the `map()` method and returns a new array with transformed values.
* `filter()`: Iterates over an array using the `filter()` method and returns a new array with filtered values.
* Closures or higher-order functions like `reduce()` or `every()`.
* Other languages or libraries that provide similar iteration methods, such as Python's `map` and `filter`, or Java 8's `Stream` API.

Keep in mind that these alternatives may not be directly comparable to the original test cases, but they could provide interesting variations for further benchmarking or experimentation.

Related benchmarks:

Object.entries vs for of (version: 0)

Comparing performance of: entries vs for vs foreach

Created: one year ago by: Guest

Jump to the latest result

entries

for

foreach

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):