Benchmark: Asterisk map replace vs stored regex replace vs make an array replace vs unfilled array replace

Script Preparation code:

var re = /./gi;
function mapReplace(value) {
  return value.split("").map((x, index, arr) => "*").join("")
}

function makeArrayReplace(value) {
  return (new Array(value.length)).fill("*").join("");
}

function makeUnfilledArrayReplace(value) {
  return (new Array(value.length + 1)).join("*");
}

function regexReplace(value) {
  return value.replace(re, "*");
}

Tests:

Map replace
const input = "abcdefghijklmnopqrstuvwxyz"; mapReplace(input);
Regex replace
const input = "abcdefghijklmnopqrstuvwxyz"; regexReplace(input);
Make array replace
const input = "abcdefghijklmnopqrstuvwxyz"; makeArrayReplace(input);
Make unfilled array replace
const input = "abcdefghijklmnopqrstuvwxyz"; makeUnfilledArrayReplace(input);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Map replace
Regex replace
Make array replace
Make unfilled array replace

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) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36 Edg/113.0.1774.42

Browser/OS: Chrome 113 on Windows

View result in a separate tab

Test name	Executions per second
Map replace	797324.7 Ops/sec
Regex replace	297964.7 Ops/sec
Make array replace	874865.6 Ops/sec
Make unfilled array replace	1241508.8 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark, hosted on MeasureThat.net, compares the performance of four different approaches for replacing characters in a string: `mapReplace`, `regexReplace`, `makeArrayReplace`, and `makeUnfilledArrayReplace`. The goal is to determine which approach is the most efficient.

**Approaches Compared**

1. **`mapReplace`**: This function uses the `Array.prototype.map()` method to create a new array, filling it with `"*"`, and then joins the elements into a string.
2. **`regexReplace`**: This function uses a regular expression (`/./gi`) to replace each character in the input string with `"*"` globally (i.e., all occurrences).
3. **`makeArrayReplace`**: Similar to `mapReplace`, but it creates an array using the `new Array()` constructor and fills it with `"*"`.
4. **`makeUnfilledArrayReplace`**: Creates an array using `new Array()` and joins its elements with `"*"`.

**Pros and Cons**

1. **`mapReplace`**:
	* Pros: Uses a built-in JavaScript method, potentially faster due to its optimized implementation.
	* Cons: May incur additional overhead for creating and managing the array.
2. **`regexReplace`**:
	* Pros: Can handle complex regular expression patterns, potentially more accurate replacements.
	* Cons: May be slower than other approaches due to the complexity of regular expressions and the need for iteration.
3. **`makeArrayReplace`**:
	* Pros: Similar to `mapReplace`, but uses a more explicit array creation method.
	* Cons: May incur additional overhead for creating and managing the array.
4. **`makeUnfilledArrayReplace`**:
	* Pros: Creates an empty array, which may be faster than creating a new array with elements.
	* Cons: May not be as efficient as `mapReplace` or `makeArrayReplace`, especially for large inputs.

**Library and Special JS Features**

The benchmark uses the following library:

1. **Regular Expressions (regex)**: The `regexReplace` function utilizes a regular expression to replace characters in the input string.
2. **Arrow Functions**: The `mapReplace` and `makeArrayReplace` functions use arrow functions for concise implementation.

**Test Case Analysis**

The test cases compare the performance of each approach on an input string `"abcdefghijklmnopqrstuvwxyz"`. The results show that:

1. **`makeUnfilledArrayReplace`** is the fastest, with approximately 297k executions per second.
2. **`mapReplace`** and `makeArrayReplace` are close in terms of execution speed, with around 800k-900k executions per second.
3. **`regexReplace`** is slower, with approximately 874k executions per second.

**Other Alternatives**

Some alternative approaches that could be considered for replacing characters in a string include:

1. Using `String.prototype.replace()` method, which might be faster than regular expressions but may not be as flexible.
2. Implementing a custom loop-based approach using basic arithmetic operations (e.g., iterating over the input string and manually building the replacement string).
3. Utilizing native JavaScript array methods like `fill()`, `map()`, or `forEach()` for creating and manipulating arrays.

These alternatives might offer trade-offs in terms of performance, readability, and maintainability, but could be considered if the specific requirements of the project dictate a different approach.

Related benchmarks:

Asterisk map replace vs stored regex replace vs make an array replace vs unfilled array replace (version: 0)

Comparing performance of: Map replace vs Regex replace vs Make array replace vs Make unfilled array replace

Created: 4 years ago by: Guest

Jump to the latest result

Map replace

Regex replace

Make array replace

Make unfilled array replace

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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