Benchmark: Comparison between replace and split map join

Script Preparation code:

const defaultSubs = {
  '1': 'i', '0': 'o', '5': 's', '9': 'g', '6': 'b', '7': 't', // eslint-disable-line
  '3': 'e', '+': 't', '$': 's', '^': 'n', '|': 'i', 'А': 'a', // eslint-disable-line
  'Б': 'b', 'В': 'b', 'Г': 'r', 'Ґ': 'r', 'Д': 'a', 'Ђ': 'h', // eslint-disable-line
  'Ѓ': 'r', 'Е': 'e', 'Ё': 'e', 'Є': 'c', 'ç': 'c', 'û': 'u', // eslint-disable-line
  'Ж': 'x', 'З': 'e', 'З́': 'e', 'Ѕ': 's', 'И': 'n', 'І': 'i', // eslint-disable-line
  'Ї': 'i', 'Й': 'n', 'Ј': 'j', 'К': 'k', 'Л': 'n', 'Љ': 'b', // eslint-disable-line
  'М': 'm', 'Н': 'h', 'Њ': 'h', 'О': 'o', 'Р': 'p', 'С': 'c', // eslint-disable-line
  'С́': 'c', 'Т': 't', 'Ћ': 'h', 'Ќ': 'k', 'У': 'y', 'Ў': 'y', // eslint-disable-line
  'Ф': 'o', 'Х': 'x', 'Ц': 'u', 'Ч': 'y', 'Џ': 'u', 'Ш': 'w', // eslint-disable-line
  'Щ': 'w', 'Ъ': 'b', 'Ы': 'bl','Ь': 'b', 'Э': 'e', 'Ю': 'io', // eslint-disable-line
  'Я': 'r', 'Ӏ': 'i', 'Ә': 'b', 'Ғ': 'r', 'Ҙ': 'e', 'Ҫ': 'c', // eslint-disable-line
  'Ҡ': 'k', 'Җ': 'x', 'Қ': 'k', 'Ң': 'h', 'Ҥ': 'h', 'Ө': 'o', // eslint-disable-line
  'Ү': 'y', 'Ұ': 'y', 'Һ': 'h', 'Ҳ': 'x', 'Α': 'a', 'α': 'a', // eslint-disable-line
  'Β': 'b', 'β': 'b', 'Γ': 'r', 'γ': 'y', 'Δ': 'a', 'δ': 'o', // eslint-disable-line
  'Ε': 'e', 'ε': 'e', 'Ο': 'o', 'ο': 'o', 'Π': 'n', 'π': 'n', // eslint-disable-line
  'Ρ': 'p', 'ρ': 'p', 'Σ': 'e', 'σ': 'o', 'ς': 'c', 'Τ': 't', // eslint-disable-line
  'τ': 't', 'Υ': 'y', 'υ': 'u', 'Φ': 'o', 'φ': 'o', 'Χ': 'x', // eslint-disable-line
  'χ': 'x', 'Ψ': 'w', 'ψ': 'w', 'Ω': 'o', 'ω': 'w', '@': 'a', // eslint-disable-line
  '4': 'a'
};

function replace1(str) {
const keys = Object.keys(defaultSubs);
  let content = str
    for (let i = 0; i < keys.length; i += 1) {
      content = str.replace(keys[i], defaultSubs[keys[i]]);
    }
  return content
}

function replace2(str) {
const strArr = str.split('').map(x => defaultSubs[x] !== undefined ? defaultSubs[x] : x).join('')
return strArr
}

Tests:

Loop
replace1('@n1m4710n n199@ 6199g4')
split map join
replace2('@n1m4710n n199@ 6199g4')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Loop
split map join

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmarking setup and explain what's being tested, compared, and their pros and cons.

**Benchmark Definition**

The test case creates two JavaScript functions: `replace1` and `replace2`. Both functions are designed to replace characters in a given string with corresponding values from an object (`defaultSubs`). The difference between the two lies in how they perform this replacement:

*   `replace1`: Iterates over each key-value pair in `defaultSubs`, replaces all occurrences of each key with its corresponding value in the input string, and returns the modified string.
*   `replace2`: Splits the input string into an array of characters using `split('')`, maps each character to its replacement value from `defaultSubs` if defined (otherwise leaves it unchanged), and then joins the array back into a string.

**Options Compared**

The two functions are compared in terms of performance:

*   `replace1`: A simple iterative approach that uses the `replace()` method.
*   `replace2`: An array-based approach that involves multiple operations (splitting, mapping, joining).

**Pros and Cons**

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

### replace1

Pros:

*   **Simple and straightforward**: The code is easy to understand and maintain.
*   **Fast iteration**: It leverages the `replace()` method's performance.

Cons:

*   **Inefficient string replacement**: It may not be as efficient as other methods since it involves multiple iterations over the input string.
*   **Potential memory issues for large inputs**: Since `replace1` modifies the original string, there might be concerns about handling large inputs that could lead to excessive memory usage.

### replace2

Pros:

*   **Efficient character-level processing**: It takes advantage of the JavaScript engine's ability to handle arrays and map operations efficiently.
*   **More memory-friendly**: By creating an array from the input string, it avoids modifying the original string, making it more suitable for handling large inputs.

Cons:

*   **Overhead due to additional operations**: The array-based approach introduces extra overhead due to splitting, mapping, and joining operations, which might affect performance for small or simple inputs.
*   **More complex code**: The logic is slightly more intricate compared to `replace1`, making it less straightforward for some developers.

**Library Usage**

There are no libraries explicitly used in these benchmarked functions. However, JavaScript's built-in methods like `split()`, `join()`, and `map()` can be considered as part of the language's standard library.

**Special JS Features or Syntax**

The provided benchmarking setup does not use any special JavaScript features or syntax beyond what is typically available in modern JavaScript implementations.

Latest run results:

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

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

Browser/OS: Opera 86 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Loop	77837.6 Ops/sec
split map join	349447.4 Ops/sec

Related benchmarks:

Comparison between replace and split map join (version: 0)

Comparing performance of: Loop vs split map join

Created: 6 years ago by: Guest

Jump to the latest result

Loop

split map join

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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