Benchmark: indexOf vs includes in strings

Script Preparation code:

var long = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.';
var short = 'file.ext';

var s1 = 'tempor';
var s2 = '.ext';

var re1 = /tempor/;
var re2 = /\.ext/;

Tests:

includes
long.includes(s1); long.includes(s2); short.includes(s1); short.includes(s2);
!~indexOf
!~long.indexOf(s1); !~long.indexOf(s2); !~short.indexOf(s1); !~short.indexOf(s2);
indexOf > -1
long.indexOf(s1) > -1; long.indexOf(s2) > -1; short.indexOf(s1) > -1; short.indexOf(s2) > -1;
indexOf !== -1
long.indexOf(s1) !== -1; long.indexOf(s2) !== -1; short.indexOf(s1) !== -1; short.indexOf(s2) !== -1;
test
re1.test(long); re2.test(long); re1.test(short); re2.test(short);
match
long.match(re1) !== null; long.match(re2) !== null; short.match(re1) !== null; short.match(re2) !== null;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
includes
!~indexOf
indexOf > -1
indexOf !== -1
test
match

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36

Browser/OS: Chrome 120 on Linux

View result in a separate tab

Test name	Executions per second
includes	1498346.0 Ops/sec
!~indexOf	1499284.0 Ops/sec
indexOf > -1	1505453.2 Ops/sec
indexOf !== -1	1503583.9 Ops/sec
test	1142791.1 Ops/sec
match	1057815.9 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of the provided JavaScript microbenchmark.

**Benchmark Definition**

The benchmark is defined in two parts: Script Preparation Code and Html Preparation Code (which is empty in this case). The script preparation code defines several variables:

1. `long`: A long string containing a large amount of text.
2. `short`: A short string with the extension `.ext`.
3. Two strings `s1` and `s2`, which are substrings of `long` and `short`, respectively.
4. Two regular expressions `re1` and `re2`, which match `s1` and `s2`, respectively.

**Benchmarked Functions**

The benchmark compares the performance of four different JavaScript functions:

1. `includes(str, substring)`: Returns `true` if the string contains the substring.
2. `indexOf(str, substring)`: Returns the index of the first occurrence of the substring in the string.
3. `!~str.indexOf(substring)`: A logical NOT version of `indexOf`, which returns `true` if the substring is not found.
4. `long.match(re)` and `short.match(re)`: Return the matched text or `null` if no match is found, using the regular expression `re`.

**Options Compared**

The benchmark compares the performance of these four functions for different cases:

* `includes(s1)` and `includes(s2)`: Tests the performance of `includes` on short substrings.
* `!~indexOf(s1)` and `!~indexOf(s2)`: Tests the performance of logical NOT `indexOf`.
* `indexOf > -1` (and its variants): Tests the performance of `indexOf` with a more complex condition.
* `test(re1, long)` and `test(re2, short)`: Tests the performance of regular expression matching.

**Pros and Cons**

Here's a brief summary of the pros and cons for each approach:

* `includes(str, substring)`: Fast, simple, but may not be suitable for large strings or complex patterns.
* `indexOf(str, substring)`: More accurate than `includes`, but slower due to its algorithmic complexity. May also return `-1` if the substring is not found.
* `!~str.indexOf(substring)`: Faster than `indexOf`, but less accurate (as it doesn't check for substrings). Can be optimized using a single call with `=== -1`.
* `long.match(re)` and `short.match(re)`: Generally faster than `includes` or `indexOf`, but may not handle edge cases correctly.

**Other Considerations**

* The use of `!~` instead of `=== -1` is an optimization technique that takes advantage of the fact that `!~a && a !== -1` is equivalent to `a === -1`. This can be more efficient in terms of execution time.
* Regular expressions (`re`) are used for pattern matching, which can be faster than string comparison. However, they may also have performance overhead due to their complexity.

**Alternatives**

If you need to benchmark other JavaScript functions or algorithms, consider the following alternatives:

1. Microbenchmarking libraries like Benchmark.js or JSMeter.
2. Online benchmarking platforms like jsbench.org or Microbenchmark.net.
3. Profiling tools like Chrome DevTools' Performance or Node.js Inspector.

These tools can help you create and run more complex benchmarks, as well as provide detailed performance data and insights for optimization.

Related benchmarks:

indexOf vs includes in strings (version: 0)

Comparing performance of: includes vs !~indexOf vs indexOf > -1 vs indexOf !== -1 vs test vs match

Created: 2 years ago by: Guest

Jump to the latest result

includes

!~indexOf

indexOf > -1

indexOf !== -1

test

match

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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