Benchmark: .includes() vs .test() vs .match() vs .indexOf() vs .search() fix2

Script Preparation code:

var text = (Math.random() + 1).toString(36).substring(2)

Tests:

text.includes()
text.includes('my')
text.test()
/my/.test(text)
text.match()
text.match(/my/)?.length >= 0
text.indexOf()
text.indexOf('my') >= 0
text.search()
text.search('my') >= 0

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
text.includes()
text.test()
text.match()
text.indexOf()
text.search()

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:109.0) Gecko/20100101 Firefox/109.0

Browser/OS: Firefox 109 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
text.includes()	47976688.0 Ops/sec
text.test()	29817848.0 Ops/sec
text.match()	23478078.0 Ops/sec
text.indexOf()	1489414912.0 Ops/sec
text.search()	24071088.0 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

MeasureThat.net provides a JavaScript microbenchmarking tool that allows users to compare the performance of different methods for searching and verifying strings in JavaScript.

The benchmark defines five test cases:

1. `text.includes('my')`
2. `/my/.test(text)`
3. `text.match(/my/)?.length >= 0`
4. `text.indexOf('my') >= 0`
5. `text.search('my') >= 0`

Each test case measures the performance of a specific method for searching or verifying a string.

**Comparison of Methods**

1. **`includes()`**: The `includes()` method returns a boolean indicating whether the specified value is present in the string. It is generally considered to be the most efficient and readable option.
	* Pros: Easy to read and maintain, widely supported by browsers.
	* Cons: Can be slower than other methods for large strings or arrays.
2. **`.test()`**: The `test()` method returns a boolean indicating whether the specified regular expression matches the string. It is generally considered to be less efficient than `includes()`.
	* Pros: Can be useful for more complex searches, such as verifying a string against a specific pattern.
	* Cons: Can be slower and less readable than `includes()`, and may require additional configuration (e.g., regular expression syntax).
3. **`.match()`**: The `match()` method returns an array of matches if the specified regular expression matches the string. It is generally considered to be more efficient than `.test()`.
	* Pros: Can return multiple matches, useful for certain use cases.
	* Cons: Returns an array, which can be slower and less readable than a simple boolean value.
4. **`.indexOf()`**: The `indexOf()` method returns the index of the first occurrence of the specified value in the string. It is generally considered to be less efficient than `includes()`.
	* Pros: Can return the exact position of the match, useful for certain use cases.
	* Cons: Returns an index, which can be slower and less readable than a simple boolean value.
5. **`.search()`**: The `search()` method returns the index of the first occurrence of the specified regular expression in the string. It is generally considered to be less efficient than `includes()`.
	* Pros: Can return the exact position of the match, useful for certain use cases.
	* Cons: Returns an index, which can be slower and less readable than a simple boolean value.

**Library and Special Features**

No libraries are used in this benchmark. No special JavaScript features or syntax are mentioned.

**Alternative Approaches**

Other approaches to searching and verifying strings in JavaScript include:

1. **Regular expressions**: Regular expressions can be used to search for patterns in strings, but they can be complex and difficult to read.
2. **Array methods**: Array methods like `some()`, `every()`, or `find()` can be used to search and verify arrays of strings.
3. **String iteration**: String iteration using a loop can be used to search and verify strings, but it can be slower than other methods.

Overall, the `includes()` method is generally considered to be the most efficient and readable option for searching and verifying strings in JavaScript.

Related benchmarks:

.includes() vs .test() vs .match() vs .indexOf() vs .search() fix2 (version: 0)

Comparing performance of: text.includes() vs text.test() vs text.match() vs text.indexOf() vs text.search()

Created: one year ago by: Guest

Jump to the latest result

text.includes()

text.test()

text.match()

text.indexOf()

text.search()

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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