Benchmark: Map .has() vs .get()

Script Preparation code:

function noop() {}
map = new Map();
keys = [];

for (let i = 0; i < 10000; i++) {
  const k = new Number(i);
  keys.push(k);
  if (k % 2 !== 0) map.set(k, i);
}

Tests:

.has() and .get()
keys.forEach(k => { if (map.has(k)) noop(map.get(k)); })
.get() only
keys.forEach(k => { const v = map.get(k); if (v) noop(v); })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
.has() and .get()
.get() only

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.1:latest, generated one month ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Benchmark Overview**

The provided JSON represents a benchmark definition for comparing two different approaches to accessing values from a `Map` object in JavaScript. The goal is to measure which approach is more efficient: using the `.has()` and then `.get()` methods, or only using the `.get()` method with an additional check for truthiness.

**Test Case 1: `.has() and .get()`**

This test case uses a `forEach` loop to iterate over an array of keys (`keys`) and checks if each key exists in the map using `.has(key)`. If the key exists, it retrieves its associated value using `.get(key)` and calls the `noop` function with this value.

**Test Case 2: `.get() only**`

This test case is similar to the first one, but instead of checking if the key exists in the map before retrieving its value, it directly uses the `.get()` method to retrieve the value. If the retrieved value is truthy (i.e., not `null` or `undefined`), it calls the `noop` function with this value.

**Library and Features Used**

In this benchmark, no external libraries are used besides the built-in JavaScript `Map` object. The only special feature used is the `.has()` method of the `Map` object, which checks if a key exists in the map. This method returns a boolean value indicating whether the key exists or not.

**Pros and Cons**

The two approaches being compared have different trade-offs:

* **.has() and .get():**
	+ Pros: More explicit and easier to understand for developers who are familiar with `.has()` checks.
	+ Cons: May be slower due to the additional check using `.has()`.
* **.get() only:**
	+ Pros: Faster because it avoids an extra method call.
	+ Cons: May lead to unexpected behavior if the retrieved value is `null` or `undefined`, which could require additional checks.

**Other Alternatives**

Besides these two approaches, there are other ways to access values from a `Map` object:

* **.get() with optional chaining**: If the `.get()` method returns an empty string (`""`), you can use optional chaining (`?.`) to check if the value is truthy.
* **.get() with ternary operator**: You can use a ternary operator to return a default value or call `noop` function only when the retrieved value is truthy.

**Considerations**

When deciding which approach to use, consider the following:

* If you need to explicitly check if a key exists before retrieving its associated value, use `.has()` and `.get()`.
* If performance is crucial, and you're confident that the values will always be truthy when retrieved, use `.get() only`.

Keep in mind that these alternatives are not mutually exclusive, and you can combine different approaches to achieve your specific use case requirements.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36

Browser/OS: Chrome 124 on Linux

View result in a separate tab

Test name	Executions per second
.has() and .get()	763.9 Ops/sec
.get() only	1033.2 Ops/sec

Related benchmarks:

Map .has() vs .get() (version: 3)

This is to compare the cost of this pattern ```if (map.has(key)) func1(map.get(key))``` v/s ```const v = map.get(key); if (v) func1(v);```

Comparing performance of: .has() and .get() vs .get() only

Created: 6 years ago by: Registered User

Jump to the latest result

.has() and .get()

.get() only

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.1:latest, generated one month ago):