Benchmark: split-join vs regex replace

Script Preparation code:

String.prototype.replaceAll = function(search, replacement) {
    var target = this;
    return target.replace(new RegExp(search, 'g'), replacement);
};

Tests:

replace regex
"this is it".replace(/ /g, "+");
split-join
"this is it".split(" ").join("+");

Historical Performance Data aggregated from 29 community runs

Desktop Results:

Chrome 21 runs

replace regex

12.5M/s

split-join

12.1M/s

View exact numbers

✓ replace regex: 12,479,851 ops/sec
• split-join: 12,085,601 ops/sec

Firefox 8 runs

split-join

6.8M/s

replace regex

6.7M/s

View exact numbers

✓ split-join: 6,828,330 ops/sec
• replace regex: 6,661,585 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
replace regex
split-join

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Firefox 138 on Windows

View result in a separate tab

replace regex

3.9M/s

split-join

3.5M/s

View exact numbers

Test name	Executions per second
✓ replace regex	3,874,800 Ops/sec
split-join	3,493,848 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 provided benchmark definition and test cases.

**Benchmark Definition:**

The benchmark measures the performance of two approaches to replace spaces in a string:

1. **Regex Replace**: Using regular expressions (`/regex/g`) to replace all whitespace characters with a plus sign (`+`).
2. **Split-Join**: Splitting the string into an array using whitespace as the delimiter, and then joining it back together using the plus sign (`+`).

**Options Compared:**

The benchmark compares two options:

1. Regex Replace (using regular expressions)
2. Split-Join (using string methods)

**Pros and Cons of Each Approach:**

**Regex Replace:**

Pros:

* Can be more efficient for complex replacement patterns
* Can handle multi-character whitespace characters

Cons:

* May have a higher overhead due to the use of regular expressions
* Can be slower than simple string methods

**Split-Join:**

Pros:

* Typically faster than regex replace for simple string operations
* More predictable performance, as it relies on the underlying string method implementation

Cons:

* May not handle complex replacement patterns
* Can be slower for multi-character whitespace characters

**Other Considerations:**

* The benchmark uses a fixed input string (`"this is it"`), which may limit the applicability of the results.
* The test cases only cover two specific scenarios, so the results may not generalize to other use cases.

**Libraries and Special JS Features:**

None of the test cases explicitly use any libraries or special JavaScript features beyond the standard `String.prototype` methods.

**Alternatives:**

If you were to rewrite this benchmark, you might consider adding additional test cases to cover more scenarios, such as:

* Using different types of whitespace characters (e.g., tabs, newlines)
* Handling edge cases (e.g., empty strings, null inputs)
* Comparing the performance of regex replace with other string manipulation methods (e.g., `String.prototype.replace()` without the global flag)

In terms of alternative approaches, you might also consider:

* Using a library like Lodash's `replace` function for regex replacement
* Utilizing JavaScript engines' built-in optimizations for string operations

Keep in mind that these alternatives would depend on your specific use case and requirements.

split-join vs regex replace (version: 0)

Comparing performance of: `replace regex vs split-join`

Created: 5 years ago by: Guest

Go to the latest result

replace regex

split-join

Historical Performance Data aggregated from 29 community runs

Desktop Results:

Chrome 21 runs

Firefox 8 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

split-join vs regex replace (version: 0)

Comparing performance of: replace regex vs split-join

Created: 5 years ago by: Guest

Go to the latest result

replace regex

split-join

Historical Performance Data aggregated from 29 community runs

Desktop Results:

Chrome 21 runs

Firefox 8 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: `replace regex vs split-join`