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

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]
object[“0”]
object["0"]

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]
object[“0”]

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of what is tested on MeasureThat.net.

**Benchmark Overview**

The benchmark measures the performance of accessing different types of data structures and values in JavaScript:

1. Maps (object with key-value pairs)
2. WeakMaps (objects that automatically delete keys when their corresponding values are no longer referenced)
3. Arrays (sequences of values)
4. Objects with direct property access using a symbol

**Options Compared**

The benchmark compares the performance of accessing these data structures and values using different syntaxes:

1. Map `get` method
2. WeakMap `get` method
3. Array index access (`array[0]`)
4. Object property access using an object literal (`object.a`)
5. Object property access using a symbol (`object[symbol]`)
6. Object property access using bracket notation with a string value (`object["0"]`)

**Pros and Cons of Each Approach**

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

1. **Map `get` method**: This is the most efficient way to access map values, as it uses a hash table lookup. However, it may not be supported in older browsers.
2. **WeakMap `get` method**: Similar to Map, but with the added benefit of automatic key deletion when the value is no longer referenced. However, this can lead to performance issues if the map grows too large.
3. **Array index access (`array[0]`)**: This is a simple and efficient way to access array values, but it may not be supported in older browsers that don't support arrays.
4. **Object property access using an object literal (`object.a`)**: This is a straightforward way to access object properties, but it can lead to slower performance due to the need for string concatenation or lookup.
5. **Object property access using a symbol (`object[symbol]`)**: This is a modern way to access object properties, but it may not be supported in older browsers that don't support symbols.
6. **Object property access using bracket notation with a string value (`object["0"]`)**: This is another way to access object properties, but it can lead to slower performance due to the need for string concatenation or lookup.

**Library Used**

The benchmark uses the following libraries:

1. `Map`: The JavaScript `Map` constructor creates an object that stores key-value pairs.
2. `WeakMap`: The JavaScript `WeakMap` constructor creates an object that stores key-value pairs, but automatically deletes keys when their corresponding values are no longer referenced.

**Special JS Feature or Syntax**

The benchmark uses the following special feature or syntax:

1. **Symbols**: Symbols are a new type of property in JavaScript that was introduced in ECMAScript 2015. They can be used to create unique and efficient property names.

Note: If you're not familiar with symbols, don't worry! You can skip this section if you prefer.

**Other Alternatives**

If you want to test other data structures or values in your benchmark, consider adding the following:

1. **Set**: An object that stores unique values.
2. **Date**: A primitive value that represents a point in time.
3. **RegExp**: A regular expression object that can be used to match patterns.

You can also experiment with different data types and structures, such as arrays of objects or complex objects with nested properties.

Keep in mind that the performance of your benchmark may vary depending on the specific use case and requirements. MeasureThat.net provides a great starting point for exploring JavaScript performance, but you may need to modify or extend the benchmark to suit your needs.

Latest run results:

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

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

Browser/OS: Chrome 124 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Map.get	28912326.0 Ops/sec
WeakMap.get	26544018.0 Ops/sec
array[0]	28397164.0 Ops/sec
object.a	28786108.0 Ops/sec
object[symbol]	15630047.0 Ops/sec
object[“0”]	28769420.0 Ops/sec

Related benchmarks:

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

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

Created: one year ago by: Guest

Jump to the latest result

Map.get

WeakMap.get

array[0]

object.a

object[symbol]

object[“0”]

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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