Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
Feature Requests
FAQ
Register
Log In
JavaScript string split vs match using regex
(version: 0)
Benchmark.js
Comparing performance of:
split vs match
Created:
2 years ago
by:
Guest
Go to the latest result
Script Preparation code:
string = "This benchmark is testing if split or match is faster on a string using regex"; regex = /\S+/gi;
Tests:
split
string.split(regex)
match
string.match(regex)
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (2)
Previous results
Fork
Test case name
Result
split
match
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_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36
Browser/OS:
Chrome 135 on Mac OS X 10.15.7
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=602283" width="100%" height="500px"></iframe>
match
2.6M/s
split
1.9M/s
View exact numbers
Test name
Executions per second
✓
match
2,594,362 Ops/sec
split
1,879,216 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
Let's break down the provided benchmark definition and test cases. **Benchmark Definition:** The benchmark is designed to compare the performance of two JavaScript methods: `string.split()` and `string.match()`, both using regular expressions (`regex`). The regular expression used is `/\\S+/gi`, which matches one or more non-whitespace characters (including newline) globally (`g` flag). **Options Compared:** The benchmark compares the execution time of: 1. `string.split(regex)` 2. `string.match(regex)` **Pros and Cons of Approaches:** * **Split Method:** + Pros: - More intuitive for string splitting, as it explicitly returns an array of substrings. + Cons: - May create unnecessary intermediate arrays, potentially leading to higher memory usage and slower performance in some cases. * **Match Method:** + Pros: - Returns the entire match as a string, which can be more convenient for certain use cases (e.g., accessing the matched text). + Cons: - May require additional processing to extract the actual substring from the match result. **Library and Purpose:** There is no specific library used in this benchmark. The `string` and `regex` variables are built-in JavaScript primitives. **Special JS Feature/Syntax:** The regular expression `/\\S+/gi` uses: * The `\S+` pattern, which matches one or more non-whitespace characters (equivalent to `[^\s]+`). * The `g` flag, which enables global matching. * The `i` flag, which makes the match case-insensitive. **Other Considerations:** * The benchmark only measures performance for two specific use cases, so the results may not be representative of all possible scenarios. * The test cases do not account for other factors that might affect performance, such as string length or the complexity of the regular expression pattern. **Alternatives:** For this type of benchmark, alternatives could include: * Comparing the performance of `string.split()` and `Array.prototype.slice()` (which can be more efficient in some cases). * Using a different regular expression pattern to simulate different use cases. * Adding additional variables or conditions to test how performance changes with varying input sizes, data types, or complexity. Keep in mind that benchmarks should aim to isolate specific aspects of the code under test and provide meaningful results. In this case, the benchmark focuses on comparing two methods using regular expressions, making it a good starting point for testing performance in similar scenarios.
Related benchmarks
str.match vs str.Split(regex)
str.match vs str.split vs deconstruction
Comments
Confirm delete:
Do you really want to delete benchmark?