Benchmark: Access Object, Map, Array, Set

Script Preparation code:

var obj = {"one": true, "two": true, "three": true, "four": true, "five": true, "six": true, "seven": true, "eight": true, "nine": true, "ten": true};
var map = new Map([["one", true], ["two", true], ["three", true], ["four", true], ["five", true], ["six", true], ["seven", true], ["eight", true], ["nine", true], ["ten", true]]);

var arr = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"];
var set = new Set(["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"]);

Tests:

Get from Object
var value = obj['ten'];
Has key in Object
var has = 'ten' in obj;
Get from Map
var value = map.get('ten');
Has key in Map
var has = map.has('ten');
Get from Array
var value = arr[9];
Has key in Array OLD
var has = arr.indexOf('ten') > -1;
Has key in Array NEW
var has = arr.includes('ten');
Has key in Set
var has = set.has('ten');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Get from Object
Has key in Object
Get from Map
Has key in Map
Get from Array
Has key in Array OLD
Has key in Array NEW
Has key in Set

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 10 months ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36

Browser/OS: Chrome 137 on Windows

View result in a separate tab

Test name	Executions per second
Get from Object	200134096.0 Ops/sec
Has key in Object	214039232.0 Ops/sec
Get from Map	193566592.0 Ops/sec
Has key in Map	216034960.0 Ops/sec
Get from Array	190794672.0 Ops/sec
Has key in Array OLD	80746200.0 Ops/sec
Has key in Array NEW	80329016.0 Ops/sec
Has key in Set	222430672.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of JavaScript operations can be interesting. I will break down what is being tested on this provided JSON.

The benchmark tests access to different types of data structures:

1.  **Objects**: These are key-value pairs where each key has an associated value. In the benchmark, we have a single object `obj` with 10 properties (`one`, `two`, ..., `ten`) all set to `true`. We test accessing these values using two methods: direct property access (`obj['ten']`) and the `in` operator (`'ten' in obj`).
2.  **Maps**: These are similar to objects, but they also support iteration over their key-value pairs.
3.  **Arrays**: A sequence of elements of the same data type. We test accessing array values by index (`arr[9]`) and membership testing using two methods: `indexOf()` (older method) and `includes()` (newer method).
4.  **Sets**: A collection of unique elements, which can be used for fast membership testing.

Now let's examine the different approaches:

**Objects**

*   Direct Property Access (`obj['ten']`): This is straightforward but may have some overhead due to JavaScript engine's optimization.
*   `in` Operator (`'ten' in obj`): The `in` operator checks if a property exists. It can be more efficient than direct property access because it doesn't require the same level of type checking.

**Maps**

*   Map Iteration over Key-Value Pairs: Maps do not provide a direct way to get a value by its key (like objects). Instead, we use `map.get(key)` or `map.has(key)`. The former returns the value associated with that key, while the latter checks if the map has that key.

**Arrays**

*   Index-Based Access (`arr[9]`): This is efficient because arrays are implemented as contiguous blocks of memory. However, this approach doesn't work when dealing with large datasets or non-numeric keys.
*   `indexOf()` and `includes()`: The older `indexOf()` method returns the index of the first occurrence of a specified element (or -1 if not found). The newer `includes()` method checks for membership in an array and returns a boolean value.

**Sets**

*   Membership Testing (`set.has(element)`): Sets provide a fast way to check for membership. They are implemented using hash tables, which have an average time complexity of O(1) for lookups.

In conclusion, the choice of approach depends on your specific use case and requirements:

-   If you need direct access to an object property or need to iterate over its key-value pairs, `map.get()` is a good option.
-   For membership testing in sets, they provide the most efficient solution due to their hash-based implementation.

Hope this explanation helped clarify what's being measured in this benchmark.

Related benchmarks:

Access Object, Map, Array, Set (version: 3)

Comparing performance of: Get from Object vs Has key in Object vs Get from Map vs Has key in Map vs Get from Array vs Has key in Array OLD vs Has key in Array NEW vs Has key in Set

Created: 5 years ago by: Registered User

Jump to the latest result

Get from Object

Has key in Object

Get from Map

Has key in Map

Get from Array

Has key in Array OLD

Has key in Array NEW

Has key in Set

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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