Benchmark: Replace string methods, .replace(), replaceAll(), and split+join +

Script Preparation code:

var strOut = '';
var strIn = 'This is just a test';
var just = 'just';
var reg = /just/;

Tests:

Replace
strOut = strIn.replace('just', '');
Replace All
strOut = strIn.replaceAll('just', '');
Split+Join
strOut = strIn.split('just').join('');
Replace from var
strOut = strIn.replace(just, '');
Replace all from var
strOut = strIn.replaceAll(just, '');
Split+join from var
strOut = strIn.split(just).join('');
Replace with template literal
strOut = strIn.replace(`${just}`, '');
Split+join with template literal
strOut = strIn.split(`${just}`).join('');
Replace with regex
strOut = strIn.replace(reg, '');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Replace
Replace All
Split+Join
Replace from var
Replace all from var
Split+join from var
Replace with template literal
Split+join with template literal
Replace with regex

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:128.0) Gecko/20100101 Goanna/6.7 Firefox/128.0 PaleMoon/33.8.0

Browser/OS: Pale Moon (Firefox Variant) 33 on Windows

View result in a separate tab

Test name	Executions per second
Replace	2186013.5 Ops/sec
Replace All	1629302.0 Ops/sec
Split+Join	1713948.2 Ops/sec
Replace from var	2173808.5 Ops/sec
Replace all from var	1572099.5 Ops/sec
Split+join from var	1162375.9 Ops/sec
Replace with template literal	2200713.0 Ops/sec
Split+join with template literal	1056602.8 Ops/sec
Replace with regex	968771.4 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 JavaScript string replacement methods, including `replace()`, `replaceAll()`, and various concatenation approaches with template literals or regular expressions.

**Options being compared:**

1. **`strOut = strIn.replace('just', '');`**: Replaces all occurrences of the substring "just" in the input string using a simple string comparison.
2. **`strOut = strIn.replaceAll('just', '');`**: Replaces all occurrences of the substring "just" in the input string using the `replaceAll()` method, which is often faster than `replace()`.
3. **`strOut = strIn.split('just').join('');`**: Splits the input string into an array of substrings at the position of "just", then joins them back together without any separators.
4. **`strOut = strIn.replace(just, '');`**: Replaces all occurrences of the variable `just` in the input string using a simple string comparison. This approach assumes that `just` is a constant string value.
5. **`strOut = strIn.replaceAll(just, '');`**: Replaces all occurrences of the variable `just` in the input string using the `replaceAll()` method, which is often faster than `replace()`.
6. **`strOut = strIn.split(`${just}`).join('');`**: Splits the input string into an array of substrings at the position of the template-literal expression `${just}`, then joins them back together without any separators.
7. **`strOut = strIn.replace(`${just}`, '');`**: Replaces all occurrences of the template-literal expression `${just}` in the input string using a simple string comparison.
8. **`strOut = strIn.split(${just}).join('');`**: Splits the input string into an array of substrings at the position of the template-literal expression ${just}, then joins them back together without any separators.
9. **`strOut = strIn.replace(reg, '');`**: Replaces all occurrences of the regular expression `reg` in the input string using a simple string comparison.

**Performance considerations:**

* The `replaceAll()` method is often faster than `replace()` because it can take advantage of native optimization and avoid unnecessary string comparisons.
* Using template literals can provide better performance by avoiding the overhead of creating a new function or function call.
* Regular expressions can be slower than simple string comparisons due to their complexity and the overhead of parsing and executing them.

**Benchmark results:**

The provided benchmark results show that the `replaceAll()` method is generally faster than the other approaches, followed closely by template literals. The regular expression approach tends to be slower due to its complexity. The `split() + join()` approach can also be slow if the input string is large and the separator is a common substring.

Overall, this benchmark highlights the importance of choosing the right string replacement method depending on the specific use case and performance requirements.

Related benchmarks:

Replace string methods, .replace(), replaceAll(), and split+join + (version: 0)

Comparing performance of: Replace vs Replace All vs Split+Join vs Replace from var vs Replace all from var vs Split+join from var vs Replace with template literal vs Split+join with template literal vs Replace with regex

Created: 3 years ago by: Guest

Jump to the latest result

Replace

Replace All

Split+Join

Replace from var

Replace all from var

Split+join from var

Replace with template literal

Split+join with template literal

Replace with regex

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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