Benchmark: indexOf VS object

Tests:

indexOf found
const arr = [1,2,3,4,5,6,7,8,9,10]; let isFound = (-1 != arr.indexOf(8));
indexOf not found
const arr = [1,2,3,4,5,6,7,8,9,10]; let isFound = (-1 != arr.indexOf(12));
object found
const obj = {1 : true,2 : true,3 : true,4 : true,5 : true,6 : true,7 : true,8 : true,9 : true,10 : true}; let isFound = (obj["8"]);
object not found
const obj = {1 : true,2 : true,3 : true,4 : true,5 : true,6 : true,7 : true,8 : true,9 : true,10 : true}; let isFound = (obj["12"]);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
indexOf found
indexOf not found
object found
object not found

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 90 on Windows

View result in a separate tab

Test name	Executions per second
indexOf found	65420384.0 Ops/sec
indexOf not found	63486956.0 Ops/sec
object found	71720168.0 Ops/sec
object not found	70072336.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark definitions and explain what is being tested.

The benchmark measures the performance of three different JavaScript operations: `indexOf` with a found element, `indexOf` with an undefined index, object lookup (`obj[key]`) when the key exists, and object lookup (`obj[key]`) when the key does not exist.

**1. `indexOf` with a found element**

This operation tests whether the `indexOf` method returns -1 for a valid index. The benchmark definition:
```javascript
const arr = [1,2,3,4,5,6,7,8,9,10];
let isFound = (-1 != arr.indexOf(8));
```
The purpose of this test is to verify that the `indexOf` method returns -1 when the element at the specified index does not exist. In modern JavaScript, it's common for `indexOf` to return -1 when the index is out of bounds.

**Pros:**

* Simple and straightforward operation.
* Easy to understand and execute.

**Cons:**

* May not be representative of real-world scenarios where `indexOf` might be used with invalid indices.
* Can be optimized by the browser, making it less relevant for performance comparison.

**2. `indexOf` with an undefined index**

This operation tests whether the `indexOf` method throws a TypeError or returns an error when the specified index is undefined. The benchmark definition:
```javascript
const arr = [1,2,3,4,5,6,7,8,9,10];
let isFound = (-1 != arr.indexOf(12));
```
The purpose of this test is to verify that the `indexOf` method handles invalid indices correctly.

**Pros:**

* Helps ensure that browsers handle errors and edge cases correctly.
* Relevant for performance comparison in scenarios where invalid indices might be used.

**Cons:**

* May introduce unnecessary overhead due to error handling.
* Can lead to false positives if the browser optimizes away the error.

**3. Object lookup (`obj[key]`) when the key exists**

This operation tests whether the object lookup syntax (`obj[key]`) returns a value for an existing key. The benchmark definition:
```javascript
const obj = {1 : true,2 : true,3 : true,4 : true,5 : true,6 : true,7 : true,8 : true,9 : true,10 : true};
let isFound = (obj["8"]);
```
The purpose of this test is to verify that the object lookup syntax returns a value for an existing key.

**Pros:**

* Relevant for performance comparison in scenarios where object lookup is used.
* Helps ensure that browsers handle object literals correctly.

**Cons:**

* May introduce unnecessary overhead due to string interpolation.
* Can lead to false positives if the browser optimizes away the string interpolation.

**4. Object lookup (`obj[key]`) when the key does not exist**

This operation tests whether the object lookup syntax (`obj[key]`) returns undefined for a non-existent key. The benchmark definition:
```javascript
const obj = {1 : true,2 : true,3 : true,4 : true,5 : true,6 : true,7 : true,8 : true,9 : true,10 : true};
let isFound = (obj["12"]);
```
The purpose of this test is to verify that the object lookup syntax returns undefined for a non-existent key.

**Pros:**

* Relevant for performance comparison in scenarios where object lookup is used.
* Helps ensure that browsers handle object literals correctly.

**Cons:**

* May introduce unnecessary overhead due to string interpolation.
* Can lead to false positives if the browser optimizes away the string interpolation.

Other alternatives:

1. Using `hasOwnProperty()` method instead of object lookup syntax (`obj[key]`).
```javascript
const obj = {1 : true,2 : true,3 : true,4 : true,5 : true,6 : true,7 : true,8 : true,9 : true,10 : true};
let isFound = (obj.hasOwnProperty("8"));
```
This test checks if the object has a property with the given key.

Pros: More explicit and secure way to check for existence.
Cons: May be slower due to additional method call.

2. Using `in` operator instead of object lookup syntax (`obj[key]`).
```javascript
const obj = {1 : true,2 : true,3 : true,4 : true,5 : true,6 : true,7 : true,8 : true,9 : true,10 : true};
let isFound = (8 in obj);
```
This test checks if the key exists in the object using the `in` operator.

Pros: More concise and readable way to check for existence.
Cons: May be slower due to additional operator call.

3. Using `Array.prototype.includes()` method instead of `indexOf` with a found element.
```javascript
const arr = [1,2,3,4,5,6,7,8,9,10];
let isFound = (arr.includes(8));
```
This test checks if the array contains the given element using the `includes()` method.

Pros: More concise and readable way to check for existence.
Cons: May be slower due to additional method call.

Related benchmarks:

indexOf VS object (version: 0)

Comparing performance of: indexOf found vs indexOf not found vs object found vs object not found

Created: 3 years ago by: Guest

Jump to the latest result

indexOf found

indexOf not found

object found

object not found

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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