Benchmark: Array/Set/Map/ Iteration

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:

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); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Definition JSON**

The provided benchmark definition represents a set of test cases that aim to measure the performance of iterating over various data structures in JavaScript: arrays, sets, and maps. The script preparation code creates an object `obj` with 10 properties, a map `map` with 10 key-value pairs, and an array `arr` with 10 elements. Each test case uses these data structures and iterates over them using a `for...of` loop.

**Options Compared**

The benchmark compares the performance of iterating over arrays, sets, and maps in different ways:

1. **Array Iteration**: Iterating directly over the array `arr`.
2. **Set Iteration**: Iterating directly over the set `set`.
3. **Map Iteration (keys)**: Iterating over the keys of the map `map` using the `.keys()` method.
4. **Map Iteration (values)**: Iterating over the values of the map `map` using the `.values()` method.

**Pros and Cons**

Here's a brief analysis of each approach:

1. **Array Iteration**: This is the most straightforward way to iterate over an array. It has a low overhead, but it may not be as efficient as other methods if the array is very large.
2. **Set Iteration**: Similar to array iteration, iterating directly over a set can be slow if the set is very large. However, sets are optimized for fast lookups and iteration, so this approach can be beneficial if you need to frequently check membership in the set.
3. **Map Iteration (keys)**: Iterating over map keys provides faster lookup times compared to iterating over values or using array indices. This approach is suitable when you need to access key-value pairs by their keys.
4. **Map Iteration (values)**: While not as fast as iterating over keys, iterating over map values can still provide good performance if the map is relatively small.

**Other Considerations**

* When working with large datasets, it's essential to consider memory usage and garbage collection impact on performance.
* Using `for...of` loops for iteration is generally faster than using traditional `forEach()` or indexing-based approaches.
* Avoiding unnecessary computations, such as using `Object.keys()` instead of accessing properties directly, can improve performance.

**Library Usage**

The benchmark uses the `Map` and `Set` constructors from the JavaScript Standard Library. These libraries provide efficient implementations for working with maps and sets, respectively.

**Special JS Features/Syntax**

This benchmark does not explicitly use any special JavaScript features or syntax, such as async/await, Promises, or generators. The focus is on demonstrating iteration performance using traditional loop constructs.

Now that we've explored the benchmark definition and options compared, let's look at the alternative approaches:

* **Iterating over array indices**: This approach can be faster than iterating directly over arrays but requires manual indexing.
* **Using `forEach()` with a callback function**: While `forEach()` is generally slower than `for...of` loops, it can still provide good performance if the callback function is optimized and doesn't cause unnecessary computations.
* **Using third-party libraries or frameworks**: Depending on your specific use case, using a library like Lodash or Ramda might offer better performance for certain iteration tasks.

Keep in mind that this benchmark focuses on demonstrating the basic trade-offs between iterating over arrays, sets, and maps. The actual best approach will depend on your specific requirements and the characteristics of your data.

Latest run results:

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

User agent: Mozilla/5.0 (Android 13; Mobile; rv:108.0) Gecko/108.0 Firefox/108.0

Browser/OS: Firefox Mobile 108 on Android

View result in a separate tab

Test name	Executions per second
Array Iteration	11266089.0 Ops/sec
Map Iteration	2447880.8 Ops/sec
Map Iteration (keys)	2837296.8 Ops/sec
Map Iteration (values)	2866248.0 Ops/sec
Set Iteration	3165024.8 Ops/sec

Related benchmarks:

Array/Set/Map/ Iteration (version: 0)

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

Created: one year ago by: Guest

Jump to the latest result

Array Iteration

Map Iteration

Map Iteration (keys)

Map Iteration (values)

Set Iteration

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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