Benchmark: includes vs indexOf with start position

includes vs indexOf with start position (version: 0)

Comparing performance of: includes from start vs includes true vs includes false vs indexOf true vs indexOf false vs indexOf nonexistent vs slice includes true vs slice includes false vs substring includes true vs substring includes false vs substring indexOf true vs substring indexOf false

Created: 5 years ago by: Guest

Jump to the latest result

Script Preparation code:

 var lorem = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.\nPraesent congue, ipsum non scelerisque convallis Lorem ipsum dolor sit amet, consectetur adipiscing elit. Praesent congue, ipsum non scelerisque convallis Lorem ipsum dolor sit amet, consectetur adipiscing elit. Praesent congue, ipsum non scelerisque convallis Lorem ipsum dolor sit amet, consectetur adipiscing elit. Praesent congue, ipsum non scelerisque convallis";

Tests:

includes from start
lorem.includes('\n');
includes true
lorem.includes('\n', 50);
includes false
lorem.includes('\n', 70);
indexOf true
lorem.indexOf('\n') > 50;
indexOf false
lorem.indexOf('\n') > 70;
indexOf nonexistent
lorem.indexOf('\t') > 70;
slice includes true
lorem.slice(50).includes('\n');
slice includes false
lorem.slice(70).includes('\n');
substring includes true
lorem.substring(50).includes('\n');
substring includes false
lorem.substring(70).includes('\n');
substring indexOf true
lorem.substring(50).indexOf('\n') !== -1;
substring indexOf false
lorem.substring(70).indexOf('\n') !== -1;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
includes from start
includes true
includes false
indexOf true
indexOf false
indexOf nonexistent
slice includes true
slice includes false
substring includes true
substring includes false
substring indexOf true
substring indexOf false

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 dive into the benchmark and explain what's being tested.

**Benchmark Definition**

The benchmark is designed to compare the performance of three string methods: `includes`, `indexOf`, and their variants with different start positions (`includes` and `indexOf` with optional second argument).

**String Methods Compared**

1. **includes**: Returns true if a specified value exists in a string, or false otherwise.
2. **indexOf**: Returns the index of the first occurrence of a specified value in a string, or -1 if not found.

The benchmark tests these methods on a large string with various scenarios:

* `includes` with different start positions
* `indexOf` with different start positions (first and last occurrences)
* Variants with different start positions (`includes` and `indexOf`)

**Performance Comparison**

The benchmark measures the execution time of each method for each scenario, providing a performance comparison.

**Interpretation**

The results indicate that:

1. **includes** is generally slower than `indexOf`, especially when searching from the beginning or end of the string.
2. `indexOf` with different start positions shows varying performance depending on the starting index and the presence of the target value in the string.
3. The variants (`includes` and `indexOf`) with different start positions do not offer significant performance improvements over their baseline counterparts.

**Conclusion**

The benchmark highlights the importance of choosing the right string method for your use case, considering factors such as performance, ease of implementation, and compatibility with different platforms and browsers.

Related benchmarks: