Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
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
Go to the latest result
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>
Run tests (4)
Previous results
Fork
Test case name
Result
array
set
Array for Each
Set for Each
Fastest:
N/A
Slowest:
N/A
Latest run results:
Run details:
(Test run date:
one month ago
)
User agent:
Mozilla/5.0 (X11; Linux x86_64; rv:152.0) Gecko/20100101 Firefox/152.0
Browser/OS:
Firefox 152 on Linux
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=630039" width="100%" height="500px"></iframe>
Array for Each
54K/s
array
44K/s
Set for Each
32K/s
set
14K/s
View exact numbers
Test name
Executions per second
✓
Array for Each
53,713 Ops/sec
array
44,295 Ops/sec
Set for Each
31,559 Ops/sec
set
14,383 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
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 100k elements
set vs array iteration + for each - large arrays - sum
Comments
Confirm delete:
Do you really want to delete benchmark?