Benchmark: set.has vs. Object lookup vs. key in Object

Script Preparation code:

var a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var b = {1: true, 2: true, 3: true, 4: true, 5: true, 6: true, 7: true, 8: true, 9: true, 10: true}

Tests:

includes
return a.includes(9)
key lookup
return !!b['9']
key in obj lookup
return '9' in b

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
includes
key lookup
key in obj lookup

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 104 on Windows

View result in a separate tab

Test name	Executions per second
includes	14049403.0 Ops/sec
key lookup	14035786.0 Ops/sec
key in obj lookup	11037396.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested, compared, and the pros/cons of each approach.

**Benchmark Definition**

The benchmark is designed to compare three different ways to check if a value exists in an object: using the `includes()` method on an array, using the `!!` syntax for key lookup, and using the `in` operator for key-in-object lookup.

**Script Preparation Code**

The script prepares two arrays and objects:

* An array `a` with values from 1 to 10.
* An object `b` with keys and values matching the array `a`.

**Html Preparation Code**

There is no HTML preparation code, which means that the benchmark only focuses on JavaScript performance.

**Individual Test Cases**

The benchmark consists of three individual test cases:

1. **includes**: This test case checks if the value 9 exists in the array `a` using the `includes()` method.
2. **key lookup**: This test case checks if the key '9' exists in the object `b` using the `!!` syntax.
3. **key in obj lookup**: This test case checks if the key '9' exists in the object `b` using the `in` operator.

**Pro/Cons of each approach**

1. **includes() method on an array**:
	* Pros: Fast and efficient, as it uses a linear search algorithm.
	* Cons: May not be suitable for large arrays or strings, as it can lead to performance issues.
2. **!! syntax for key lookup**:
	* Pros: Can be faster than the `in` operator for small objects, as it avoids the overhead of the operator.
	* Cons: Less readable and maintainable than other approaches, as it relies on a binary operation (`!!`) instead of a clear method call.
3. **key in obj lookup**:
	* Pros: Fast and efficient, as it uses a direct lookup mechanism.
	* Cons: May not be suitable for very large objects or arrays, as it can lead to performance issues.

**Other considerations**

* The benchmark is run on a Chrome 104 browser on a desktop platform with Windows operating system.
* The `includes()` method is used to search the array from start to end, which may lead to faster results if the value exists early in the array. However, this might not be the case for all use cases.
* The `!!` syntax is used for key lookup, but it's worth noting that this syntax can lead to unexpected behavior when used with other data types or in more complex scenarios.

**Alternatives**

Other alternatives to these approaches could include:

* Using a library like Lodash or Ramda for array and object manipulation.
* Implementing custom lookup methods using bitwise operations or regular expressions.
* Using alternative key-in-object lookup mechanisms, such as `Object.hasOwn()` or `Object.prototype.hasOwnProperty.call()`.

Related benchmarks:

set.has vs. Object lookup vs. key in Object (version: 0)

Comparing performance of: includes vs key lookup vs key in obj lookup

Created: 2 years ago by: Guest

Jump to the latest result

includes

key lookup

key in obj lookup

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