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

Script Preparation code:

var map = new Map([["0",1]]);

var array = [1];

var symbol = Symbol('next');
var object = {["0"]: 1, [symbol]: 1 };
var weakMap = new WeakMap([[object,1]])
var x = 0;

Tests:

Map.get
x += map.get("0");
WeakMap.get
x += weakMap.get(object)
array[0]
x += array[0]
object.a
x += object.a
object[symbol]
x += 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 year ago)

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

Browser/OS: Chrome 136 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Map.get	17832704.0 Ops/sec
WeakMap.get	17493770.0 Ops/sec
array[0]	18560010.0 Ops/sec
object.a	18386114.0 Ops/sec
object[symbol]	17309896.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The provided benchmark measures the performance difference between accessing elements of an array, object, map, and weak map.

Let's break down each test case:

1. `array[0]`:
	* This test case accesses the first element of the array using square brackets (`[]`). In JavaScript, when you access an array element using square brackets, the browser needs to perform a lookup in the array's index table.
	* The pros of this approach are that it's simple and straightforward. However, since arrays are not hash tables, looking up an element by its index can be slower than other methods (see below).
2. `object.a`:
	* This test case accesses the property `a` on the object using dot notation (`.`). In JavaScript, when you access an object property using dot notation, the browser needs to perform a lookup in the object's property table.
	* The pros of this approach are that it's simple and straightforward. However, since objects are not hash tables, looking up a property by its name can be slower than other methods (see below).
3. `Map.get()`:
	* This test case accesses the value associated with the key `"0"` using the `Map.get()` method.
	* Maps in JavaScript are implemented as hash tables, which means that lookups are typically very fast. The pros of this approach are that it's optimized for lookup operations and can be faster than other methods (see below).
4. `WeakMap.get()`:
	* This test case accesses the value associated with the key `object` using the `WeakMap.get()` method.
	* Weak maps in JavaScript are also implemented as hash tables, but they have a few additional features that make them suitable for use cases where you don't need to store references to the keys (e.g., garbage collection). The pros of this approach are that it's optimized for lookup operations and can be faster than other methods (see below).
5. `object[symbol]`:
	* This test case accesses the value associated with the symbol `next` using square brackets (`[]`). In JavaScript, when you access an object property using square brackets, the browser needs to perform a lookup in the object's index table.
	* The pros of this approach are that it's simple and straightforward. However, since objects are not hash tables, looking up a property by its symbol can be slower than other methods (see below).

Comparison:

| Method | Pros | Cons |
| --- | --- | --- |
| Array[0] | Simple | Can be slower due to lookup in index table |
| Object.a | Simple | Can be slower due to lookup in property table |
| Map.get() | Optimized for lookups | Requires a `Map` object, which may not always be available |
| WeakMap.get() | Optimized for lookups | Requires a `WeakMap` object, which may not always be available |
| Object[symbol] | Simple | Can be slower due to lookup in index table |

In general, the fastest approach will depend on the specific use case and requirements. However, in general, using maps or weak maps for lookups can be faster than using arrays or objects.

Other alternatives:

* Using `Object.keys()` or `Object.values()` instead of dot notation or square brackets to access object properties.
* Using `Array.prototype.indexOf()` or `Array.prototype.findIndex()` instead of direct indexing on an array element.
* Using other data structures, such as sets or queues, if they are more suitable for the specific use case.

Note that this benchmark is just one way to measure performance, and different test cases may prioritize different aspects (e.g., memory usage, CPU cycles).

Related benchmarks:

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

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

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