Benchmark: Access Object, Map, Array, Set with n items #2

Script Preparation code:

var length = 10000;
var key = '5000';
var obj = Array.from({length}).reduce((obj,_,index) => {obj[index.toString()] = index; return obj}, {});
var map = new Map(Array.from({length}).map((_,index) => [index.toString(), index]));

var arr = Array.from({length}).map((_,index) => index.toString());
var set = new Set(Array.from({length}).map((_,index) => index.toString()));

Tests:

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

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Get from Object
Get from Map
Has key in Map
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: 3 years ago)

User agent: Mozilla/5.0 (Windows NT 6.3; Win64; x64; rv:86.0) Gecko/20100101 Firefox/86.0

Browser/OS: Firefox 86 on Windows 8.1

View result in a separate tab

Test name	Executions per second
Get from Object	142965520.0 Ops/sec
Get from Map	4172566.8 Ops/sec
Has key in Map	2195928.2 Ops/sec
Has key in Array OLD	1303.3 Ops/sec
Has key in Array NEW	1448.0 Ops/sec
Has key in Set	5649638.5 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll dive into explaining the benchmark and its various components.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmark created using MeasureThat.net. The benchmark tests different ways to access and check for the presence of a key in an object, map, array, and set data structures.

**Script Preparation Code**

The script preparation code is a crucial part of the benchmark:
```javascript
var length = 10000;
var key = '5000';
var obj = Array.from({length}).reduce((obj,_,index) => {obj[index.toString()] = index; return obj}, {});
var map = new Map(Array.from({length}).map((_,index) => [index.toString(), index]));
var arr = Array.from({length}).map((_,index) => index.toString());
var set = new Set(Array.from({length}).map((_,index) => index.toString()));
```
This code creates four data structures:

1. `obj`: an object with 10,000 properties ( keys ) and corresponding values.
2. `map`: a map (equivalent to an object in JavaScript) with 10,000 entries, where each key is a string representation of an integer index.
3. `arr`: an array with 10,000 elements, all strings representing integer indices.
4. `set`: a set (similar to an array in JavaScript but without duplicates) containing the same integer indices as the array.

These data structures are used throughout the benchmark to test different access and lookup methods.

**Test Cases**

The benchmark consists of six individual test cases:

1. "Get from Object" (`var value = obj[key];`)
2. "Get from Map" (`var value = map.get(key);`)
3. "Has key in Map" (`var has = map.has(key);`)
4. "Has key in Array OLD" (`var has = arr.indexOf(key) > -1;`) ( deprecated)
5. "Has key in Array NEW" (`var has = arr.includes(key);`)
6. "Has key in Set" (`var has = set.has(key);`)

Each test case measures the execution time for a specific access or lookup operation.

**Browser Results**

The latest benchmark results show the performance metrics for each browser, including:

* `RawUAString`: the user agent string of the browser.
* `Browser`: the actual browser name and version.
* `DevicePlatform`: the device platform (Desktop/ mobile).
* `OperatingSystem`: the operating system used by the browser.
* `ExecutionsPerSecond`: the number of executions performed per second.

**Pros and Cons of Different Approaches**

Here's a brief analysis of each approach:

1. **Accessing an object using bracket notation (`obj[key]`)**: This is the most direct way to access a property in an object. Pros: simple, efficient; Cons: may not work well with non-numeric keys or objects with complex structures.
2. **Using `Map.get(key)`**: This method provides more control over the lookup process and is suitable for larger datasets. Pros: flexible, efficient; Cons: may incur additional overhead due to map operations.
3. **Checking if a key exists in an array using `arr.indexOf(key) > -1`** (deprecated): This approach can be slow and may not work well with large arrays. Pros: simple; Cons: deprecated, inefficient.
4. **Using `Array.includes(key)`**: This method is more efficient than the previous one but still less efficient than direct bracket notation access. Pros: more efficient than deprecated approach; Cons: requires modern JavaScript versions.
5. **Checking if a key exists in a set using `set.has(key)`**: Sets are optimized for fast lookups, making this approach very efficient. Pros: extremely fast; Cons: may not be suitable for all use cases.

**Other Considerations**

* The benchmark uses a relatively small dataset (10,000 items), which might affect the results.
* The script preparation code creates temporary data structures, which can impact performance if executed multiple times.
* MeasureThat.net allows users to add custom scripts and modify existing ones, making it a flexible testing framework.

**Alternative Benchmarking Tools**

MeasureThat.net is just one of many benchmarking tools available. Other popular alternatives include:

1. **Benchmark.js**: A lightweight, Node.js-based benchmarking tool.
2. **jsbench**: A browser-based benchmarking platform for JavaScript tests.
3. **BenchPress**: A Python library for creating and running benchmarks.

Keep in mind that each tool has its strengths and weaknesses, and the choice of benchmarking tool depends on your specific needs and goals.

Related benchmarks:

Access Object, Map, Array, Set with n items #2 (version: 0)

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

Created: 3 years ago by: Guest

Jump to the latest result

Get from Object

Get from Map

Has key in Map

Has key in Array OLD

Has key in Array NEW

Has key in Set

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):