Benchmark: JS Map get VS JS Map has

Script Preparation code:

var i = 0, count = 1000, a;
var map = new Map();

for (i = 0; i < count; i++) {
  if (Math.random() > 0.5) {
    map.set(i, i * i);
  }
}

Tests:

Map 1
for (i = 0; i < count; i++) { map.get(i); }
Map 2
for (i = 0; i < count; i++) { map.has(i); }

Historical Performance Data aggregated from 27 community runs

Desktop Results:

Chrome 27 runs

Map 2

20K/s

Map 1

19K/s

View exact numbers

✓ Map 2: 19,598 ops/sec
• Map 1: 19,301 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Map 1
Map 2

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 148 on Windows

View result in a separate tab

Map 2

31K/s

Map 1

30K/s

View exact numbers

Test name	Executions per second
✓ Map 2	30,732 Ops/sec
Map 1	30,087 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one year ago):

LLMs can make mistakes. Check important info.

The benchmark in question compares two different approaches to accessing elements in a JavaScript `Map` object: using the `.get()` method and the `.has()` method.

### What is being tested?

1. **Method Under Test**:
   - **Map 1**: This test case executes the `.get()` method on the `Map`, which retrieves the value associated with a given key.
   - **Map 2**: This test case executes the `.has()` method on the `Map`, which checks if a specified key exists in the `Map` without returning the value.

### Advantages and Disadvantages

- **Using `Map.get()`**:
  - **Pros**:
    - Directly retrieves the value associated with the key if it exists, which is useful when you need both existence and value.
  - **Cons**:
    - If the key does not exist, this method will return `undefined`, and it may require additional checks if you need to determine if the key is present prior to using the value.

- **Using `Map.has()`**:
  - **Pros**:
    - It is purely focused on the existence check. It returns a boolean value indicating the presence of the key, which can be simpler and can potentially optimize any subsequent logic, as it avoids returning an undefined value when a key does not exist.
  - **Cons**:
    - If a value is needed after checking the existence, you'll still have to perform another call to `Map.get()`, which means two lookups instead of one.

### Considerations

- **Performance**: The benchmark results show that `Map.has()` performs faster than `Map.get()` in this particular test, with approximately 8533 executions per second versus 8476 for `Map.get()`. This indicates that using `Map.has()` could be a more efficient choice when only the existence of the key is needed.
- **Use Case**: If the use case requires frequently checking the presence of keys without needing the associated values, using `Map.has()` is likely the better approach.

### Library Usage

No external libraries are used in this benchmark; it employs the native JavaScript `Map` object, which is part of the ECMAScript 2015 (ES6) specification. `Map` objects are designed to hold key-value pairs and maintain the order of entries. Their methods (`.get()`, `.has()`, etc.) provide a more efficient way of handling key-value pairs compared to standard objects, especially when dealing with non-string keys.

### Alternatives

- **Using Objects**: Before `Map` was introduced, JavaScript developers would often use plain objects for similar purposes. However, unlike `Map`, keys in objects can only be strings (or symbols), which can lead to unexpected behavior when using non-string keys. Additionally, object keys do not maintain insertion order, making `Map` a more suitable choice for ordered collections.
- **WeakMap**: If you do not need to directly access or iterate through all keys, a `WeakMap` might be an alternative. It holds weak references to keys and allows for garbage collection of keys when there are no other references to them, which can help manage memory more efficiently in certain contexts. However, `WeakMap` only supports objects as keys and does not provide iteration capabilities.

In conclusion, this benchmark provides valuable insights into the performance characteristics of two approaches to accessing data in a `Map`, helping developers make informed decisions based on their specific needs in JavaScript applications.

JS Map get VS JS Map has (version: 1)

Map get VS Map has

Comparing performance of: `Map 1 vs Map 2`

Created: one year ago by: Guest

Go to the latest result

Map 1

Map 2

Historical Performance Data aggregated from 27 community runs

Desktop Results:

Chrome 27 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one year ago):

JS Map get VS JS Map has (version: 1)

Map get VS Map has

Comparing performance of: Map 1 vs Map 2

Created: one year ago by: Guest

Go to the latest result

Map 1

Map 2

Historical Performance Data aggregated from 27 community runs

Desktop Results:

Chrome 27 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one year ago):

Related benchmarks

Comparing performance of: `Map 1 vs Map 2`