Benchmark: Value existance check in object, array, map, set

Script Preparation code:

var randomStringsToGenerate = 10000;

var array = [];
var set = new Set();
var object = {};
var map = new Map();

for (let i = 0; i < randomStringsToGenerate; i++) {
  array.push(i);
  map.set(i, true);
  object[i] = true;
  set.add(i);
}

Tests:

array
return array.includes(5000)
set
return set.has(5000)
object
return object[5000]
map
return map.has(5000)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array
set
object
map

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 years ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36

Browser/OS: Chrome 90 on Linux

View result in a separate tab

Test name	Executions per second
array	143841.0 Ops/sec
set	12059111.0 Ops/sec
object	12792256.0 Ops/sec
map	12246240.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark definition and test cases.

**Benchmark Definition**

The website `MeasureThat.net` provides a JSON representation of a JavaScript microbenchmark, which consists of:

1. **Script Preparation Code**: This code is executed once to prepare the environment for the benchmark. In this case, it generates 10,000 random strings, creates an array, set, object, and map, and populates them with these random strings.
2. **Html Preparation Code**: This field is empty in this example, indicating that no HTML-related preparation code is required.
3. **Benchmark Definition**: The actual benchmark script, which defines a simple function to test the value existence check in different data structures (array, set, object, and map).

**Individual Test Cases**

There are four individual test cases:

1. `return array.includes(5000)`
	* This test case tests whether an element with the value 5000 exists in the array.
2. `return set.has(5000)`
	* This test case tests whether an element with the value 5000 exists in the set.
3. `return object[5000]`
	* This test case tests whether an element with the value 5000 exists in the object using property access.
4. `return map.has(5000)`
	* This test case tests whether an element with the value 5000 exists in the map.

**Options Compared**

The benchmark compares four different approaches to check for value existence:

1. **Array**: Using the `includes()` method or iterating through the array to find the desired element.
2. **Set**: Using the `has()` method, which returns a boolean indicating whether an element with the specified value exists in the set.
3. **Object**: Using property access (`object[5000]`) to check if an element with the value 5000 exists as a property of the object.
4. **Map**: Using the `has()` method, similar to the set.

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

1. **Array**: Pros:
	* Wide support across browsers and platforms.
	* Can be used for indexing and iteration as well.
Cons:
	* May require more iterations or comparisons if searching for an element in a large array.
2. **Set**: Pros:
	* Fast lookups due to the hash-based data structure.
	* Generally more efficient than arrays for unique values.
Cons:
	* May not be suitable for ordered collections or requiring exact matches.
3. **Object**: Pros:
	* Wide support across browsers and platforms.
	* Can be used for property access, but may require more complex logic if searching for multiple properties.
Cons:
	* May be slower than array lookups due to property access overhead.
4. **Map**: Pros:
	* Similar benefits to sets for fast lookups and efficient data structures.
	* Suitable for ordered collections or requiring exact matches.
Cons:
	* May not be as widely supported as arrays or objects.

**Library and Special JS Features**

There are no specific libraries mentioned in the benchmark definition, but sets and maps are built-in JavaScript data structures. Property access (`object[5000]`) is also a native feature of JavaScript.

No special JavaScript features are explicitly used in this benchmark. However, if we were to consider more advanced scenarios, features like `WeakMap` or `Proxy` might be used for specific use cases.

**Alternatives**

If you're looking for alternatives to these approaches:

1. **Use `Array.prototype.find()`**: If searching for the first occurrence of a value in an array.
2. **Use `Set.prototype.has()` with a timeout**: If performance-critical and using the built-in `has()` method is too slow.
3. **Use `Object.keys()` or `Object.values()`**: For iterating through object properties or values, but be aware that these methods can be slower than direct property access.

These alternatives might not provide the exact same benefits as the original approaches, but they offer alternative trade-offs and performance characteristics.

Related benchmarks:

Value existance check in object, array, map, set (version: 0)

Value existance check in object, array, map, set

Comparing performance of: array vs set vs object vs map

Created: 3 years ago by: Guest

Jump to the latest result

array

set

object

map

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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