Benchmark: str.match vs str.Split

Script Preparation code:

string = "This is a benchmark to test if matching a regex is faster that splitting a string";
regex = /\S+/gi;

Tests:

String.split
string.split(" ")
Regex.match
string.match(regex)

Historical Performance Data aggregated from 234 community runs

Desktop Results:

Chrome 171 runs

String.split

10.9M/s

Regex.match

1.6M/s

Fastest: String.split (6.6x faster)

View exact numbers

✓ String.split: 10,912,101 ops/sec
• Regex.match: 1,641,791 ops/sec

Firefox 46 runs

String.split

3.7M/s

Regex.match

2.0M/s

Fastest: String.split (1.8x faster)

View exact numbers

✓ String.split: 3,674,074 ops/sec
• Regex.match: 2,003,800 ops/sec

Safari 11 runs

String.split

15.6M/s

Regex.match

2.5M/s

Fastest: String.split (6.2x faster)

View exact numbers

✓ String.split: 15,572,216 ops/sec
• Regex.match: 2,502,902 ops/sec

Mobile Results:

Chrome 6 runs

String.split

8.1M/s

Regex.match

1.2M/s

Fastest: String.split (6.9x faster)

View exact numbers

✓ String.split: 8,095,283 ops/sec
• Regex.match: 1,169,749 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
String.split
Regex.match

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 months ago)

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

Browser/OS: Chrome 138 on Windows

View result in a separate tab

String.split

12.3M/s

Regex.match

1.6M/s

View exact numbers

Test name	Executions per second
✓ String.split	12,348,868 Ops/sec
Regex.match	1,609,296 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested.

**Benchmark Definition**

The benchmark is testing two approaches: string splitting with `String.split()` and regular expression matching with `string.match(regex)`.

**Options Compared**

The options compared are:

1. `String.split()`: This method splits a string into an array of substrings using the specified separator (in this case, a space).
2. `Regex.match()`: This method tests if a string matches a given regular expression pattern.

**Pros and Cons**

* **`String.split()`**:
	+ Pros: Simple to use, fast, and efficient for simple splitting tasks.
	+ Cons: Can be slower for large strings or complex separators, as it requires iterating over the entire string.
* **`Regex.match()`**:
	+ Pros: Flexible and powerful for matching complex patterns, but can be slower than `String.split()` due to the overhead of regular expression processing.
	+ Cons: Requires knowledge of regular expressions, which can be overwhelming for beginners.

**Library**

There is no specific library mentioned in the benchmark definition. However, it's worth noting that JavaScript has a built-in `RegExp` object that provides a way to work with regular expressions.

**Special JS Features/Syntax**

This benchmark doesn't use any special JavaScript features or syntax beyond what's standard for testing purposes. If it did, it would be mentioned in the explanation.

**Other Alternatives**

For string splitting, other alternatives might include:

* `String.prototype.split()` (if you want to avoid creating an array)
* `Array.prototype.slice()` with a specific separator
* External libraries like `lodash` or `underscore`

For regular expression matching, other alternatives might include:

* `RegExp.prototype.test()`
* `String.prototype.indexOf()` and string concatenation for simple matching

**Benchmark Preparation Code**

The script preparation code creates two variables: `string` and `regex`. The `string` variable is set to a sample string with spaces, and the `regex` variable is set to a regular expression pattern that matches non-space characters (`\\S+`) in a global match mode (`gi`). This pattern is used for the `Regex.match()` test case.

**Individual Test Cases**

The benchmark defines two individual test cases:

1. `"string.split(\" \")"`: Tests string splitting with the built-in `String.split()` method.
2. `"string.match(regex)"`: Tests regular expression matching with the `string.match()` method and the previously defined regex pattern.

**Latest Benchmark Result**

The latest benchmark result shows the execution rates for both test cases on a specific Firefox 131 browser running on Ubuntu, Desktop, Linux x86_64 hardware. The results indicate that `String.split()` is faster than `Regex.match()`.

str.match vs str.Split (version: 0)

Test String.match with regex against String.split with string. We are splitting a string at the spaces.

Comparing performance of: `String.split vs Regex.match`

Created: 6 years ago by: Guest

Go to the latest result

String.split

Regex.match

Historical Performance Data aggregated from 234 community runs

Desktop Results:

Chrome 171 runs

Firefox 46 runs

Safari 11 runs

Mobile Results:

Chrome 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

str.match vs str.Split (version: 0)

Test String.match with regex against String.split with string. We are splitting a string at the spaces.

Comparing performance of: String.split vs Regex.match

Created: 6 years ago by: Guest

Go to the latest result

String.split

Regex.match

Historical Performance Data aggregated from 234 community runs

Desktop Results:

Chrome 171 runs

Firefox 46 runs

Safari 11 runs

Mobile Results:

Chrome 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `String.split vs Regex.match`