Benchmark: indexOf vs multiple === vs object selection

Script Preparation code:

var test = 'foo';

Tests:

equals
test === 'foo' || test === 'bar';
indexOf
['foo','bar'].indexOf(test) >= 0;
object selection
({'foo':1,'bar':1})[test];

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
equals
indexOf
object selection

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

The benchmark compares three different approaches to check if a string or an object contains a specific value:

1. `===` operator ( strict equality check)
2. `indexOf()` method (searches for a substring within an array of strings)
3. Object property access (`[test]`) (directly accesses an object property using the test value as the key)

**Options Compared**

The three options are compared in terms of their execution speed and performance.

* **Pros and Cons:**
	+ `===` operator:
		- Fast, as it's a simple comparison operation.
		- May be slower for larger strings or arrays due to the need to perform multiple comparisons.
	+ `indexOf()` method:
		- Can be slower than the `===` operator, as it requires searching through an array of strings.
		- Can be faster for larger strings or arrays, as it uses a more efficient algorithm.
	+ Object property access (`[test]`):
		- Fast, as it directly accesses a specific property within an object.
		- May throw errors if the test value is not found in the object.
**Library and Special JS Features**

In this benchmark, no libraries are used. However, some special JavaScript features are used:

* **Template literals**: The `Script Preparation Code` includes template literals (`"var test = 'foo';"`), which allow for more readable string interpolation.

**Benchmark Test Cases**

The three test cases are designed to simulate different scenarios:

1. `equals`: Checks if the value of a variable is equal to a specific string using the `===` operator.
2. `indexOf`: Searches for a substring within an array of strings and checks if it's present at index 0 or greater using the `indexOf()` method.
3. `object selection`: Directly accesses an object property using the test value as the key.

**Benchmark Results**

The latest benchmark results show that:

* The `object selection` approach is the fastest, with around 36.58 million executions per second.
* The `equals` approach is slower, but still relatively fast, with around 43.16 million executions per second.
* The `indexOf` approach is the slowest, with around 36.58 million executions per second.

**Alternatives**

Some alternative approaches to these options include:

* Using regular expressions (e.g., `/test/`) for string matching
* Utilizing a more advanced data structure like a trie or suffix tree for efficient substring searching
* Employing more complex equality checks, such as using `Object.is()` or a custom comparison function

Keep in mind that the choice of approach depends on the specific use case and performance requirements.

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 119 on Windows

View result in a separate tab

Test name	Executions per second
equals	43162984.0 Ops/sec
indexOf	36585884.0 Ops/sec
object selection	43763236.0 Ops/sec

Related benchmarks:

indexOf vs multiple === vs object selection (version: 0)

Comparing performance of: equals vs indexOf vs object selection

Created: one year ago by: Guest

Jump to the latest result

equals

indexOf

object selection

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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