Benchmark: Array iter vs set iter (test order change)

Array iter vs set iter (test order change) (version: 0)

Iterate over an array vs iterating over a set.

Comparing performance of: native loop arr: few items vs for of set: few items vs for of arr: few items vs native iter set: few items vs for of arr: many items vs for of set: many items vs native loop arr: many items vs native iter set: many items

Created: 5 years ago by: Registered User

Jump to the latest result

Script Preparation code:

var fewItemArr = [1, 2, 3];
var fewItemSet = new Set(fewItemArr);
var manyItemArr = Array.from({ length: 1000 }, (_, i) => i);
var manyItemSet = new Set(manyItemArr);

Tests:

native loop arr: few items
let result = 0; for (let i = fewItemArr.length; i--;) { result += fewItemArr[i]; }
for of set: few items
let result = 0; for (const item of fewItemSet) { result += item; }
for of arr: few items
let result = 0; for (const item of fewItemArr) { result += item; }
native iter set: few items
let result = 0; let val = null; const iter = fewItemSet.values(); while (!(val = iter.next()).done) { result += val.value; }
for of arr: many items
let result = 0; for (const item of manyItemArr) { result += item; }
for of set: many items
let result = 0; for (const item of manyItemSet) { result += item; }
native loop arr: many items
let result = 0; for (let i = manyItemArr.length; i--;) { result += manyItemArr[i]; }
native iter set: many items
let result = 0; let val = null; const iter = manyItemSet.values(); while (!(val = iter.next()).done) { result += val.value; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
native loop arr: few items
for of set: few items
for of arr: few items
native iter set: few items
for of arr: many items
for of set: many items
native loop arr: many items
native iter set: many items

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

I'll break down the benchmark test and its components.

**Benchmark Test Overview**

The test measures the performance of iterating over arrays versus sets in JavaScript, specifically comparing:

1. Using `for` loops
2. Using the `for...of` loop syntax
3. Using a `while` loop with a `values()` iterator

**Script Preparation Code**

The script preparation code creates two types of data structures: an array (`fewItemArr`) and a set (`fewItemSet`). The array has only a few items, while the set is converted from the same array to demonstrate performance differences.

```javascript
var fewItemArr = [1, 2, 3];
var fewItemSet = new Set(fewItemArr);

var manyItemArr = Array.from({ length: 1000 }, (_, i) => i);
var manyItemSet = new Set(manyItemArr);
```

**Iteration Approaches**

The test compares four iteration approaches:

1. **Native Loop**: Using a `for` loop with the index variable.
```javascript
let result = 0;
for (let i = fewItemArr.length; i--;) {
  result += fewItemArr[i];
}
```
2. **For...of Loop on Array**: Using the `for...of` loop syntax to iterate over an array.
```javascript
let result = 0;
for (const item of fewItemArr) {
  result += item;
}
```
3. **For...of Loop on Set**: Using the `for...of` loop syntax to iterate over a set.
```javascript
let result = 0;
for (const item of fewItemSet) {
  result += item;
}
```
4. **Native Iteration with while and values()**: Using a `while` loop with a `values()` iterator to iterate over a set.
```javascript
let result = 0;
let val = null;
const iter = fewItemSet.values();
while (!(val = iter.next()).done) {
  result += val.value;
}
```
**Performance Results**

The test provides performance results for each iteration approach, measured by the number of executions per second (ExecutionsPerSecond). The results indicate that:

* Using `for...of` loops on arrays and sets is generally faster than native loops.
* Native iteration with a `while` loop and `values()` iterator can be slower than using `for...of` loops.

**Implications**

This benchmark test highlights the performance benefits of using `for...of` loops when iterating over arrays and sets. It also shows that native iteration can sometimes be less efficient, but may offer more control or flexibility in certain scenarios.

Related benchmarks: