Benchmark: Array/Set/Map/Object Iteration with entries

Script Preparation code:

var obj = {"one": true, "two": true, "three": true, "four": true, "five": true, "six": true, "seven": true, "eight": true, "nine": true, "ten": true};
var map = new Map([["one", true], ["two", true], ["three", true], ["four", true], ["five", true], ["six", true], ["seven", true], ["eight", true], ["nine", true], ["ten", true]]);

var arr = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"];
var set = new Set(["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"]);

Tests:

Object Iteration
for (const key in obj) { void(obj[key]); }
Array Iteration
for (const element of arr) { void(element); }
Map Iteration
for (const element of map) { void(element); }
Map Iteration (keys)
for (const element of map.keys()) { void(element); }
Map Iteration (values)
for (const element of map.values()) { void(element); }
Set Iteration
for (const element of set) { void(element); }
Map Iteration (entries)
for (const element of map.entries()) { void(element); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object Iteration
Array Iteration
Map Iteration
Map Iteration (keys)
Map Iteration (values)
Set Iteration
Map Iteration (entries)

Fastest: N/A

Slowest: N/A

Autogenerated LLM Sumamry (model llama3.2:3b, generated 3 days ago):

LLMs can make mistakes. Check important info.

I'll do my best to explain what's tested in the provided JSON benchmark and its implications.

**Benchmark Definition**

The benchmark measures the performance of iteration over different data structures: Arrays, Sets, Maps (including their keys, values, and entries), and Objects. The test cases aim to iterate over each element or key-value pair in these data structures using void() statements, which essentially do nothing.

**Options Compared**

The benchmark compares the performance of iterating over Arrays, Sets, and Maps using different methods:

1. **Array Iteration**: Using a traditional for loop with `in` operator to iterate over array elements.
2. **Set Iteration**: Using a traditional for loop with `in` operator to iterate over set elements.
3. **Map Iteration (keys)**: Using a traditional for loop with `.keys()` method to iterate over map keys.
4. **Map Iteration (values)**: Using a traditional for loop with `.values()` method to iterate over map values.
5. **Map Iteration (entries)**: Using a traditional for loop with `.entries()` method to iterate over map key-value pairs.

**Pros and Cons**

Each iteration method has its own advantages and disadvantages:

* **Array Iteration**: Simple, widely supported, but might be slower due to the overhead of the `in` operator.
* **Set Iteration**: Similar to Array Iteration, but with a potentially smaller set of elements.
* **Map Iteration (keys)**: Only iterates over keys, which can be faster if you only need to access them. However, it doesn't provide direct access to values.
* **Map Iteration (values)**: Iterates over values, similar to Array Iteration but with a map twist. Can be slower due to the extra step of accessing the corresponding key.
* **Map Iteration (entries)**: Provides both keys and values in each iteration step. This can be convenient, but might lead to higher overhead.

**Library Used**

None explicitly mentioned in this benchmark definition. However, it's worth noting that Maps and Sets are built-in JavaScript data structures and don't require any external libraries.

**Special JS Features or Syntax**

* The use of `void()` statements in the test cases is a way to create a no-op loop that only consumes CPU cycles without actually executing any meaningful code.
* The `.keys()`, `.values()`, and `.entries()` methods on Maps are part of the ECMAScript standard and provide convenient ways to iterate over map elements.

**Other Alternatives**

If you need more control or flexibility in your iteration, consider using:

* `forEach()` method for Arrays, Sets, and Maps
* Custom loops with iterators or `for...of` loops
* Third-party libraries like Lodash or Ramda for functional programming

Keep in mind that the performance differences between these methods can be negligible unless you're working with extremely large datasets or requiring high throughput.

Latest run results:

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

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

Browser/OS: Chrome 126 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object Iteration	3228476.0 Ops/sec
Array Iteration	34546250.0 Ops/sec
Map Iteration	22484020.0 Ops/sec
Map Iteration (keys)	26754880.0 Ops/sec
Map Iteration (values)	26626610.0 Ops/sec
Set Iteration	26789470.0 Ops/sec
Map Iteration (entries)	22550250.0 Ops/sec

Related benchmarks:

Array/Set/Map/Object Iteration with entries (version: 0)

Comparing performance of: Object Iteration vs Array Iteration vs Map Iteration vs Map Iteration (keys) vs Map Iteration (values) vs Set Iteration vs Map Iteration (entries)

Created: 3 months ago by: Guest

Jump to the latest result

Object Iteration

Array Iteration

Map Iteration

Map Iteration (keys)

Map Iteration (values)

Set Iteration

Map Iteration (entries)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Sumamry (model llama3.2:3b, generated 3 days ago):