Benchmark: For in vs Object.*.forEach vs Object.values different

Script Preparation code:

var obj = new Object()
var keys = [1000000, 1000001];
keys.forEach((x) => { obj[x.toString()] = x })

Tests:

For In with larger keys
console.log(obj.length) for( var key in obj ) { var player = obj[key]; console.log(player); }
Object values
for(let value of Object.values(obj)){ console.log(value); }
Object keys forEach
Object.keys(obj).forEach(key => console.log(obj[key]));
Object entries forEach
Object.entries(obj).forEach(([key, value]) => console.log(key,'->',value));
object values forEach
Object.values(obj).forEach(value => console.log(value));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
For In with larger keys
Object values
Object keys forEach
Object entries forEach
object values forEach

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:146.0) Gecko/20100101 Firefox/146.0

Browser/OS: Firefox 146 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
For In with larger keys	117103.7 Ops/sec
Object values	177656.4 Ops/sec
Object keys forEach	170309.4 Ops/sec
Object entries forEach	152737.9 Ops/sec
object values forEach	178838.6 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

The provided JSON represents two benchmark definitions:

**Benchmark Definition 1:**

* **For in vs Object.*.forEach vs Object.values different**
	+ This benchmark compares three approaches:
		- `for (var key in obj) { ... }`: Using a traditional `for...in` loop to iterate over the object's properties.
		- `Object.keys(obj).forEach(key => console.log(obj[key]));`: Using the `Object.keys()` method and `Array.prototype.forEach()` to iterate over the object's keys, then logging the corresponding values.
		- `Object.values(obj).forEach(value => console.log(value));`: Using the `Object.values()` method and `Array.prototype.forEach()` to directly iterate over the object's values, then logging them.

**Pros and Cons:**

* **Traditional For...in Loop**: This approach is straightforward but can be slower due to its nature of iterating over properties in a specific order (alphabetical). Additionally, it can throw an error if the object is not initialized properly.
* **Object.keys() + forEach**: This approach uses `Object.keys()` to get an array of keys and then iterates over them using `forEach`. It's generally faster than the traditional loop but may be slower than iterating directly over values due to the additional step of getting keys first. The use of `forEach` makes it easier to read and maintain.
* **Object.values() + forEach**: This approach uses `Object.values()` to get an array of values and then iterates over them using `forEach`. It's generally faster than the traditional loop or `Object.keys()` + `forEach` because it avoids the extra step of getting keys first. However, accessing array indices directly can be slower for very large arrays.

**Library/Functionality:**

* None are specific libraries, but rather built-in JavaScript methods.
* The use of `Array.prototype.forEach()` is a standard feature in modern JavaScript environments.

**Special JS Feature/Syntax:**

None mentioned explicitly in the benchmark definitions. However, the use of template literals (`x => { ... }`) and arrow functions (`() => { ... }`) are syntax features introduced in ECMAScript 2015 (ES6).

Now, let's consider alternatives:

* Other approaches to iterate over objects could include:
	+ Using a `for` loop with index manipulation: `for (var i = 0; i < obj.length; i++) { ... }`
	+ Using a library or framework like Lodash that provides utility functions for working with arrays and objects.
	+ Using a different data structure, such as an array of pairs (key-value) instead of an object.

Keep in mind that these alternatives might not be suitable for all use cases or environments. The provided benchmark definitions are likely designed to compare the performance of specific approaches under controlled conditions.

Related benchmarks:

For in vs Object.*.forEach vs Object.values different (version: 0)

Comparing performance of: For In with larger keys vs Object values vs Object keys forEach vs Object entries forEach vs object values forEach

Created: 3 years ago by: Guest

Jump to the latest result

For In with larger keys

Object values

Object keys forEach

Object entries forEach

object values forEach

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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