Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
set.has vs. array.includes (find 999,999 in 1,000,000)
(version: 0)
Comparing performance of:
includes vs lookup
Created:
2 years ago
by:
Guest
Go to the latest result
Script Preparation code:
var a = Array.from({length: 1000000}, (val, index) => index); var b = new Set(a)
Tests:
includes
return a.includes(999999)
lookup
return b.has(999999)
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (2)
Previous results
Fork
Test case name
Result
includes
lookup
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:151.0) Gecko/20100101 Firefox/151.0
Browser/OS:
Firefox 151 on Linux
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=629727" width="100%" height="500px"></iframe>
lookup
2024.8M/s
includes
1K/s
View exact numbers
Test name
Executions per second
✓
lookup
2,024,766,976 Ops/sec
includes
1,005 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
Let's dive into the world of JavaScript microbenchmarks and explore what's being tested on this specific benchmark. **Benchmark Overview** The provided JSON represents two test cases: `lookup` and `includes`. Both tests aim to measure the performance difference between using a `Set` data structure (with the `has` method) versus an array (with the `includes` method) for searching a large dataset containing 1 million elements, one of which is 999,999. **Options Compared** The two options being compared are: 1. **Lookup (Set)**: Using the `has` method on a `Set` data structure to search for an element. A `Set` in JavaScript is a collection of unique values, and the `has` method checks if a value exists within it. 2. **Includes (Array)**: Using the `includes` method on an array to search for an element. **Pros and Cons** * **Lookup (Set)**: + Pros: - Fast lookup times, as sets use a hash table implementation under the hood. - Efficient for large datasets, as set operations are typically faster than array operations. + Cons: - Requires an extra step to create the set from the array. - May require additional memory allocation if the set is larger than the original array. * **Includes (Array)**: + Pros: - Simpler implementation, as it only requires a linear search through the array. - Does not require creating an extra data structure (set). + Cons: - Slower lookup times compared to sets, especially for large datasets. - May be slower if the dataset is sparse or has many duplicates. **Library and Purpose** No specific libraries are used in this benchmark. However, it's worth noting that some JavaScript engines, like SpiderMonkey (used by Firefox), use optimized implementations of set operations under the hood. **Special JS Feature/Syntax** None explicitly mentioned in the provided code snippets. However, it's essential to mention that modern JavaScript engines often use various optimization techniques, such as: * **Caching**: Some engines may cache frequently accessed values or methods to improve performance. * **Inlining**: Engine optimizations can inline functions to reduce overhead and improve execution efficiency. **Alternatives** Other alternatives for benchmarking set-based operations include: 1. **Array.prototype.indexOf()**: Similar to `includes`, but returns the index of the first occurrence instead of a boolean value. 2. **Object.prototype.hasOwnProperty()**: A method that checks if an object has a specific property, which can be used as a rough equivalent to the `has` method in sets. For benchmarking array-based operations: 1. **Array.prototype.indexOf()` (mentioned above) 2. **Array.prototype.forEach()`: Although not directly comparable to `includes`, it demonstrates iteration and searching within an array. 3. **Array.prototype.map()` / **Array.prototype.filter()**: These methods can be used as benchmarks for specific use cases, such as data transformation or filtering. Keep in mind that these alternatives might not provide the exact same results or optimization strategies as the original benchmark, but they can still offer valuable insights into performance differences between various JavaScript operations.
Related benchmarks
convert to set + set.has vs. array.includes
set vs array find if exists
set.has (w/ creation) vs. array.includes
Comments
Confirm delete:
Do you really want to delete benchmark?