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))
}

​x
 
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()
runTestv1()
Find a number within a string via literal regexp
runTestv2()
runTestv2()
Find a number within a string via strong literal regexp
runTestv3()
runTestv3()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

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

Latest run results:

Run details: (Test run date: 2 years 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

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

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:

String and array methods: Using split() and findIndex().
Literal regular expression: /\\d/.
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).

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`).

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: 2 years 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 6 months ago):