Benchmark: Array vs Object vs Map vs WeakMap access (3)

Script Preparation code:

var map = new Map();
var weakMap = new WeakMap()
var array = [];
var object = {};
var symbol = Symbol('next');

Tests:

Map.get
map.get("0");
WeakMap.get
weakMap.get("0")
array[0]
array[0]
object.a
object.a
object[symbol]
object[symbol]

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Map.get
WeakMap.get
array[0]
object.a
object[symbol]

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one month ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36

Browser/OS: Chrome 148 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Map.get	276329600.0 Ops/sec
WeakMap.get	167476624.0 Ops/sec
array[0]	273373088.0 Ops/sec
object.a	273243360.0 Ops/sec
object[symbol]	272550080.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its test cases.

**Benchmark Overview**

The benchmark measures the performance of different data structures in JavaScript: Array, Object, Map, WeakMap, and using a Symbol. The goal is to compare how quickly each data structure can access a specific element or property.

**Options Compared**

Here are the options being compared:

1. **Array**: An ordered collection of values.
2. **Object**: A unordered collection of key-value pairs.
3. **Map**: An ordered map of keys to values, similar to an object but with faster lookups.
4. **WeakMap**: A specialized Map that allows for garbage collection and is suitable for storing weak references.

**Pros and Cons**

* **Array**: Pros: simple and widely supported, cons: slow lookup times due to linear search.
* **Object**: Pros: fast lookup times using property names, cons: slower than Maps or WeakMaps for large datasets.
* **Map**: Pros: fast lookups using key-value pairs, cons: requires a key to access the value.
* **WeakMap**: Pros: fast lookups with garbage collection support, cons: requires a weak reference to access the value.

**Library and Special Features**

The benchmark uses the following libraries and special features:

* **Symbol**: A primitive type in JavaScript that can be used as property names or keys. In this benchmark, it's used as a key for the Map and Object.
* None of the libraries are explicitly mentioned, but the use of Symbol suggests that the test is targeting modern browsers with support for Symbols.

**Benchmark Preparation Code**

The preparation code sets up variables to create instances of each data structure:

```javascript
var map = new Map();
var weakMap = new WeakMap();
var array = [];
var object = {};
```

This creates an empty Map, WeakMap, and Array, as well as an empty Object.

**Individual Test Cases**

Each test case measures the execution time for a specific operation:

1. `map.get("0")`: Accessing an element in the Map using its index.
2. `weakMap.get("0")`: Accessing an element in the WeakMap using its index.
3. `array[0]`: Accessing the first element of the Array.
4. `object.a`: Accessing a property on the Object using its key name.
5. `object[symbol]`: Accessing a property on the Object using the Symbol as the key.

**Benchmark Results**

The benchmark results show the execution time per second for each test case across multiple browser runs:

1. Array: 25561772 executions/second
2. Map.get: 25471548 executions/second
3. Object.a: 25326256 executions/second
4. WeakMap.get: 23898082 executions/second
5. object[symbol]: 13452492 executions/second

**Other Alternatives**

If you wanted to modify this benchmark or create a new one, consider the following alternatives:

* Use different data structures like Sets, queues, or trees.
* Introduce additional complexity by using asynchronous operations or callbacks.
* Compare performance across multiple browsers or platforms.
* Experiment with caching or memoization techniques.

Related benchmarks:

Array vs Object vs Map vs WeakMap access (3) (version: 0)

Comparing performance of: Map.get vs WeakMap.get vs array[0] vs object.a vs object[symbol]

Created: 4 years ago by: Guest

Jump to the latest result

Map.get

WeakMap.get

array[0]

object.a

object[symbol]

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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