Benchmark: Regex vs split/join

Script Preparation code:

var str = 'Abcd efghij klmnopqrstuv wxy Abcd efghij klmnopqrstuv wxy Abcd efghij klmnopqrstuv wxyAbcd efghij klmnopqrstuv wxy Abcd efghij klmnopqrstuv wxy Abcd efghij klmnopqrstuv wxy';

Tests:

Regex
str.replace(/./g, "$&Z");
Split and Join
str.split('').join('Z') + 'Z';

Historical Performance Data aggregated from 59 community runs

Desktop Results:

Chrome 40 runs

Split and Join

438K/s

Regex

219K/s

Fastest: Split and Join (2.0x faster)

View exact numbers

✓ Split and Join: 437,906 ops/sec
• Regex: 219,358 ops/sec

Firefox 13 runs

Split and Join

800K/s

Regex

90K/s

Fastest: Split and Join (8.9x faster)

View exact numbers

✓ Split and Join: 799,617 ops/sec
• Regex: 89,988 ops/sec

Safari 6 runs

Regex

160.0M/s

Split and Join

377K/s

Fastest: Regex (424.2x faster)

View exact numbers

✓ Regex: 160,042,272 ops/sec
• Split and Join: 377,305 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
Regex
Split and Join

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:145.0) Gecko/20100101 Firefox/145.0

Browser/OS: Firefox 145 on Windows

View result in a separate tab

Split and Join

697K/s

Regex

72K/s

View exact numbers

Test name	Executions per second
✓ Split and Join	697,309 Ops/sec
Regex	71,692 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark and explain what's being tested, compared, and analyzed.

**Benchmark Overview**

The benchmark measures the performance difference between using regular expressions (regex) and splitting a string into an array and then joining it with a delimiter in JavaScript. This is often referred to as "regex vs split/join" or "regex replacement vs string manipulation."

**Test Cases**

There are two test cases:

1. **Regex**: The first line of the input string `str` is replaced using regex.
```javascript
var str = 'Abcd efghij klmnopqrstuv wxy Abcd efghij klmnopqrstuv wxy Abcd efghij klmnopqrstuv wxyAbcd efghij klmnopqrstuv wxy Abcd efghij klmnopqrstuv wxy Abcd efghij klmnopqrstuv wxy';
str.replace(/./g, "$&Z");
```
The regex pattern `/./g` matches every character in the string (since `.` is a special regex pattern that matches any character), and the replacement string `$&Z` inserts the matched character followed by 'Z'. This essentially reverses the order of the characters.

2. **Split and Join**: The second line of the input string `str` is split into an array using the `split()` method and then joined back together with a delimiter `'Z'`.
```javascript
var str = 'Abcd efghij klmnopqrstuv wxy Abcd efghij klmnopqrstuv wxy Abcd efghij klmnopqrstuv wxy';
str.split('').join('Z') + 'Z';
```
The `split()` method splits the string into an array of individual characters, and the `join()` method concatenates these characters back together with the delimiter `'Z'`.

**Comparison**

The benchmark compares the performance of using regex to replace a line in the input string versus splitting the string into an array and then joining it.

**Pros and Cons**

* **Regex**: Pros:
	+ Can be more concise for simple replacements.
	+ Can perform additional operations, like matching patterns.
Cons:
	+ Can be slower due to the overhead of regular expression engines.
	+ May lead to performance issues if not used carefully (e.g., using `g` flag can cause excessive backtracking).
* **Split and Join**: Pros:
	+ Typically faster since it avoids regex engine overhead.
	+ Allows for easy debugging and modification of individual characters.
Cons:
	+ Requires more code than a simple regex replacement.

**Library Usage**

There is no explicit library usage in this benchmark. However, if you were to add libraries or external dependencies, they would likely be related to string manipulation, regex, or JavaScript performance optimization.

**Special JS Feature/Syntax**

There are no specific JavaScript features or syntaxes being tested in this benchmark. The code snippets use standard JavaScript syntax and do not include any experimental or deprecated features.

**Alternatives**

Some alternative approaches for similar benchmarks might include:

* Using a custom implementation of string manipulation functions (e.g., `replace()` or `split()`).
* Comparing the performance of different regex flavors (e.g., `g` vs. `i` flags).
* Testing the performance of using regular expressions with other languages or platforms.

Keep in mind that these alternatives would likely have different pros and cons compared to the current benchmark, and might require additional considerations when designing an experiment.

Regex vs split/join (version: 0) Benchmark.js

Comparing performance of: `Regex vs Split and Join`

Created: 9 years ago by: Guest

Go to the latest result

Regex

Split and Join

Historical Performance Data aggregated from 59 community runs

Desktop Results:

Chrome 40 runs

Firefox 13 runs

Safari 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):

Regex vs split/join (version: 0) Benchmark.js

Comparing performance of: Regex vs Split and Join

Created: 9 years ago by: Guest

Go to the latest result

Regex

Split and Join

Historical Performance Data aggregated from 59 community runs

Desktop Results:

Chrome 40 runs

Firefox 13 runs

Safari 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: `Regex vs Split and Join`