Benchmark: set vs array iteration + for each - large arrays

Script Preparation code:

const base = Array.from(Array(10000).keys())

var a = base.map(Math.random);
var b = new Set(base.map(Math.random))
var c = new Set(base.map(Math.random))
var d = base.map(Math.random);

Tests:

array
for (const x of a) {}
set
for (const x of b) {}
Array for Each
d.forEach(_ => _)
Set for Each
c.forEach(_ => _)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array
set
Array for Each
Set for Each

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.

Measuring the performance of different approaches in JavaScript can be quite fascinating.

The provided benchmark is designed to measure the performance differences between using an array and a Set data structure in JavaScript, specifically when it comes to iterating over them using `for...of` loops or the `forEach()` method. Here's a breakdown of what's being compared:

**Approaches Compared:**

1. **Array**: Using the `map()` function to create an array, which is then iterated over using a `for...of` loop.
2. **Set**: Creating a Set from an array using the `Set()` constructor and iterating over it using a `for...of` loop or the `forEach()` method.
3. **Array for Each**: Using the `map()` function to create an array, which is then iterated over using the `forEach()` method.
4. **Set for Each**: Creating two Sets from an array using the `Set()` constructor and iterating over them using the `forEach()` method.

**Pros and Cons of Different Approaches:**

1. **Array (for...of loop)**:
	* Pros: Generally faster than using `forEach()` due to native support and caching.
	* Cons: May not be as efficient for very large datasets, as it requires creating a temporary array.
2. **Set (for...of loop)**:
	* Pros: Can take advantage of native Set optimizations, such as caching and hash table lookups.
	* Cons: May require more memory to store the internal data structure.
3. **Array for Each (forEach())**:
	* Pros: Can be more convenient and easier to read than using a `for...of` loop with an array.
	* Cons: May incur additional overhead due to function calls and caching checks.
4. **Set for Each (forEach())**:
	* Pros: Can leverage the performance benefits of Sets, especially when iterating over large datasets.
	* Cons: May require more complex setup and might not be as readable.

**Other Considerations:**

1. **Language Features:** The benchmark doesn't explicitly test any special JavaScript features or syntax, such as `async/await`, generators, or classes. If these features are relevant to your use case, you may need to create additional benchmarks.
2. **Memory Allocation:** The benchmark uses large arrays and Sets, which can affect memory allocation and deallocation on the heap. Be mindful of memory constraints when running multiple iterations.

**Alternatives:**

If you want to explore other approaches or data structures, consider the following:

1. **Iterating over a Map**: Maps provide fast lookups, similar to Sets, but with additional features like key-value pairs.
2. **Custom Iterators**: You can create custom iterators using functions and the `for...of` loop to optimize iteration performance for specific use cases.
3. **Native Iterator Methods**: Some browsers and Node.js versions offer native iterator methods, such as `Symbol.iterator()`, which might provide performance benefits in certain scenarios.

Keep in mind that performance optimizations often depend on specific use cases and system configurations. Measure the impact of different approaches on your particular workload to determine the most effective solution for your needs.

Related benchmarks:

set vs array iteration + for each - large arrays (version: 0)

Comparing performance of: array vs set vs Array for Each vs Set for Each

Created: 2 years ago by: Guest

Jump to the latest result

array

set

Array for Each

Set for Each

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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