Benchmark: Includes vs indexOf

Script Preparation code:

var text = 'jdkxshklhkhskhskshkjaFREDERICKBCDBKlkhdslkbsklbsjbjkd';

Tests:

includes
text.includes('FREDERICK');
indexOf
text.indexOf('FREDERICK') !== -1;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
includes
indexOf

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark test and explain what's being tested, compared, and considered.

**What is being tested?**

The benchmark tests two different approaches to search for a string within a given text: `includes` method vs `indexOf` method.

**What are the options being compared?**

Two options are being compared:

1. **Includes Method**: The `includes` method checks if a specified string exists within another string. It returns `true` if the string is found, and `false` otherwise.
2. **IndexOf Method**: The `indexOf` method searches for the first occurrence of a specified value in a string. It returns the index of the first match, or -1 if not found.

**Pros and Cons:**

Both methods have their own pros and cons:

* **Includes Method**:
	+ Pros:
		- Faster execution time
		- More concise code
	+ Cons:
		- Can lead to performance issues with large strings
		- May return `true` for partial matches (e.g., "hello world")
* **IndexOf Method**:
	+ Pros:
		- Returns the exact index of the match, which can be useful in certain situations
		- More flexible for searching multiple occurrences
	+ Cons:
		- Slower execution time compared to `includes`
		- May not return a meaningful result if the string is empty

**Library and Purpose:**

The `text` variable used in the benchmark is an example of a JavaScript string. The `includes` and `indexOf` methods are both part of the ECMAScript standard, which means they are widely supported across different browsers and environments.

**Special JS Feature/Syntax:**

There are no special JavaScript features or syntaxes mentioned in this benchmark.

**Other Alternatives:**

Other alternatives to these two methods include:

* Using regular expressions (e.g., `RegExp.test()`) for more complex string matching
* Using a loop-based approach to iterate over the characters of the string
* Utilizing libraries like Lodash (`_.includes()` or `_indexOf()`) for more functional programming-style string searching

**Benchmark Preparation Code:**

The script preparation code creates a sample string variable `text` with a specific value, which is used in both benchmark test cases. This ensures that the same text is being searched across both tests.

**Individual Test Cases:**

Each test case measures the execution time of either the `includes` or `indexOf` method on the same text string. By comparing these two results, we can see which approach performs better in terms of speed.

In this benchmark, it appears that the `includes` method is faster than the `indexOf` method for searching a single occurrence of a string within a larger text. However, this may not always be the case, and other factors like device, browser, and system configuration can influence performance results.

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/87.0.4280.66 Safari/537.36

Browser/OS: Chrome 87 on Windows

View result in a separate tab

Test name	Executions per second
includes	5640741.5 Ops/sec
indexOf	7570530.0 Ops/sec

Related benchmarks:

Includes vs indexOf (version: 0)

Includes vs indexOf

Comparing performance of: includes vs indexOf

Created: 6 years ago by: Registered User

Jump to the latest result

includes

indexOf

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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