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

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

Autogenerated LLM Summary (model llama3.2:3b, generated one year 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.

Related benchmarks:

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

Comparing performance of: equals vs indexOf vs object selection

Created: 2 years ago by: Guest

Jump to the latest result

equals

indexOf

object selection

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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