Benchmark: Literal regexp's vs string and array methods

Script Preparation code:

const tests = [
	'Alasdkfjdsfndv dfjwsdfsmd +\
		s@sdfsdvdsv dwoaslkvkl +\
		skcslmvklfnkl klaml fm +\
		wemvfz;lpakpokqmdsfdkm +\
		kreklmswlms lmfklsmskl +\
		l;fl; s,dl;fmsklnkfsd; +\
		sahfwijrn 1',
	'3Jognsahasdojjjdishuihjnj +\
	 	sdfskdfkshfskmfsdjnf',
	'Asnasbdbasdahsfsdjfsdfbds +\
		eiejdksjhsjj7'
]

function strContainsNumsv1(str) {
	return str.split('').findIndex(e => [0,1,2,3,4,5,6,7,8,9].includes(+e)) != -1;
}

function strContainsNumsv2(str) {
	return /\d/.test(str);
}

function strContainsNumsv3(str) {
	return /^(?=.*[0-9]).*$/.test(str);
}

function runTestv1() {
	tests.forEach(e => strContainsNumsv1(e))
}

function runTestv2() {
	tests.forEach(e => strContainsNumsv2(e))
}

function runTestv3() {
	tests.forEach(e => strContainsNumsv3(e))
}

Tests:

Find a number within a string via string and array methods
runTestv1()
Find a number within a string via literal regexp
runTestv2()
Find a number within a string via strong literal regexp
runTestv3()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Find a number within a string via string and array methods
Find a number within a string via literal regexp
Find a number within a string via strong literal regexp

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the benchmark.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmark that compares three approaches to search for a digit (number) within a given string:

1. **String and array methods**: Using `split()` and `findIndex()`.
2. **Literal regular expression**: `/\\d/`.
3. **Strong literal regular expression**: `/^(?=.*[0-9]).*$/`.

**Approaches Compared**

The benchmark compares the execution time of each approach for a set of test cases.

* **String and array methods (`strContainsNumsv1`)**: Splits the input string into an array of characters, then uses `findIndex()` to find the index of the first character that is a digit.
* **Literal regular expression (`strContainsNumsv2`)**: Uses the `/\\d/` pattern to match any single digit within the input string. The `test()` method returns a boolean indicating whether the entire string matches this pattern.
* **Strong literal regular expression (`strContainsNumsv3`)**: Uses the `/^(?=.*[0-9]).*$/` pattern, which is more restrictive than the previous one, ensuring that the string contains at least one digit. The `test()` method returns a boolean indicating whether the entire string matches this pattern.

**Pros and Cons**

Here's a brief overview of each approach:

* **String and array methods**: Pros: simple to implement, easy to read. Cons: may be slower than regular expression approaches due to the overhead of creating an array and iterating over it.
* **Literal regular expression (`strContainsNumsv2`)**: Pros: concise, easy to write, and relatively fast. Cons: may not match all edge cases (e.g., non-ASCII digits).
* **Strong literal regular expression (`strContainsNumsv3`)**: Pros: more robust than the previous approach, ensures that the string contains at least one digit. Cons: more complex pattern, potentially slower due to the additional overhead.

**Library and Special JS Features**

There are no notable libraries or special JavaScript features used in this benchmark.

**Other Considerations**

When choosing between these approaches, consider the trade-off between performance, code readability, and robustness:

* If speed is critical, and you're willing to compromise on code readability, use the literal regular expression (`strContainsNumsv2`).
* If you need a more robust solution that ensures the presence of at least one digit, use the strong literal regular expression (`strContainsNumsv3`).
* If simplicity and ease of implementation are more important than performance, use the string and array methods (`strContainsNumsv1`).

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36

Browser/OS: Chrome 108 on Windows

View result in a separate tab

Test name	Executions per second
Find a number within a string via string and array methods	337716.2 Ops/sec
Find a number within a string via literal regexp	1255559.8 Ops/sec
Find a number within a string via strong literal regexp	734599.6 Ops/sec

Related benchmarks:

Literal regexp's vs string and array methods (version: 0)

Literal regexp's vs string and array methods when searching a number in a string

Comparing performance of: Find a number within a string via string and array methods vs Find a number within a string via literal regexp vs Find a number within a string via strong literal regexp

Created: one year ago by: Guest

Jump to the latest result

Find a number within a string via string and array methods

Find a number within a string via literal regexp

Find a number within a string via strong literal regexp

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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