Benchmark: replaceAll vs regex replace vs string split join

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, "+");
replace All
"this is it".replaceAll(" ", "+");
string split join
"this is it".split(" ").join("+");

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
replace regex
replace All
string split join

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36 Edg/132.0.0.0

Browser/OS: Chrome 132 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
replace regex	11494558.0 Ops/sec
replace All	6145420.5 Ops/sec
string split join	14006131.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested in the provided JSON benchmark.

**Benchmark Definition**

The benchmark is designed to compare three different approaches for replacing or manipulating strings:

1. `replaceAll`: a custom implementation of string replacement using a loop.
2. `replace`: a standard JavaScript method for regular expression-based string replacement.
3. `split` and `join`: methods for splitting a string into an array and then joining it back together with a separator.

**Options Compared**

The three options are compared in terms of performance, specifically the number of executions per second on a given device platform (Desktop).

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

1. `replaceAll`:
	* Pros: Simple to understand and implement, might be faster for small strings due to reduced overhead from regular expressions.
	* Cons: Inefficient for large strings due to the loop overhead, may not work correctly with edge cases or Unicode characters.
2. `replace`:
	* Pros: Standard JavaScript method, well-documented, and widely supported; can handle edge cases and Unicode characters.
	* Cons: May be slower than custom implementations due to regular expression compilation and matching overhead.
3. `split` and `join`:
	* Pros: Efficient for large strings since they only require two operations (split and join), relatively fast.
	* Cons: Requires an extra step (array creation), might not be as efficient for very small strings.

**Library Used**

None, the benchmark uses standard JavaScript methods (`replaceAll`, `replace`, `split`, and `join`) without any external libraries.

**Special JS Feature/Syntax**

There is no special JavaScript feature or syntax being tested in this benchmark. The focus is on comparing different string manipulation approaches.

**Other Alternatives**

If you were to design an alternative benchmark, you might consider:

1. Comparing the performance of custom implementations using different data structures (e.g., arrays vs. linked lists) or algorithms (e.g., brute force vs. optimized searching).
2. Investigating the impact of various factors on string manipulation performance, such as:
	* String length
	* Character encoding
	* Frequency of replacements or manipulations
	* Device platform and operating system differences

Feel free to ask if you'd like me to elaborate on any of these points!

Related benchmarks:

replaceAll vs regex replace vs string split join (version: 0)

Comparing performance of: replace regex vs replace All vs string split join

Created: one year ago by: Guest

Jump to the latest result

replace regex

replace All

string split join

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