Benchmark: replace vs substring vs slice from END

replace vs substring vs slice from END (version: 0)

Test the performance of replace() vs substring() vs slice() when replacing a char at the beginning of a (in this case uri query-)string that may or may not be there. Added the combined brackets[ ] + substr() method, since it's always the first char we wan't to pop off. Inspired by https://jsperf.com/replace-or-substr. Note: could not get 'let' and 'const' to work. Well, too bad...

Comparing performance of: `substring vs replace inline regex vs replace compiled regex var vs slice`

Created: 3 years ago by: Guest

Go to the latest result

Script Preparation code:

var strIn = 'https://www.data-xata.com/all-servers.html';
var strOut = '';
var regex = /\.html$/;

Tests:

substring
strOut = strIn.substring(0,strIn.length-5) + '.JS'
replace inline regex
strOut = strIn.replace(/\.html$/, '.JS');
replace compiled regex var
strOut = strIn.replace(regex, '.JS');
slice
strOut = strIn.slice(0,-5) + '.JS'

Historical Performance Data aggregated from 77 community runs

Desktop Results:

Chrome 58 runs

slice

9.5M/s

substring

8.1M/s

replace inline regex

6.4M/s

replace compiled regex var

6.2M/s

Fastest: slice (1.5x faster)

View exact numbers

✓ slice: 9,516,557 ops/sec
• substring : 8,055,457 ops/sec
• replace inline regex: 6,408,332 ops/sec
• replace compiled regex var: 6,174,955 ops/sec

Firefox 19 runs

slice

125.9M/s

substring

125.8M/s

replace compiled regex var

27.2M/s

replace inline regex

26.6M/s

Fastest: slice (4.7x faster)

View exact numbers

✓ slice: 125,884,544 ops/sec
• substring : 125,753,904 ops/sec
• replace compiled regex var: 27,199,170 ops/sec
• replace inline regex: 26,621,316 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
substring
replace inline regex
replace compiled regex var
slice

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:147.0) Gecko/20100101 Firefox/147.0

Browser/OS: Firefox 147 on Linux

View result in a separate tab

slice

168.3M/s

substring

161.0M/s

replace inline regex

30.5M/s

replace compiled regex var

30.4M/s

View exact numbers

Test name	Executions per second
✓ slice	168,284,048 Ops/sec
substring	160,969,152 Ops/sec
replace inline regex	30,492,524 Ops/sec
replace compiled regex var	30,361,220 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**Benchmark Overview**

The provided JSON represents a benchmark that tests the performance of three different approaches for replacing characters in a string: `replace()`, `substring()`, and `slice()`. The test cases are designed to measure the speed of each approach when replacing a character at the beginning of a URI query string.

**Options Compared**

The benchmark compares four options:

1. `strOut = strIn.substring(0, strIn.length-5) + '.JS'`
2. `strOut = strIn.replace(/\\.html$/, '.JS')`
3. `strOut = strIn.replace(regex, '.JS')` (where `regex` is a compiled regular expression)
4. `strOut = strIn.slice(0,-5) + '.JS'`

**Pros and Cons of Each Approach**

1. **Substring()**: This approach creates a new string by taking a slice of the original string. It's simple and efficient, but it can create a temporary string object, which might incur additional memory allocations.
	* Pros: Fast and simple
	* Cons: Creates a temporary string object, might be slower due to memory allocation overhead
2. **Replace() with inline regex**: This approach uses a regular expression to replace the character at the beginning of the string. It's more flexible than `substring()` but can be slower due to the additional processing required for the regex.
	* Pros: Flexible and handles edge cases well
	* Cons: Can be slower due to regex processing, might not perform as well on very large strings
3. **Replace() with compiled regex**: This approach compiles a regular expression ahead of time, which can improve performance compared to inline regexes. However, it requires more memory allocation for the compiled pattern.
	* Pros: Faster than inline regex due to compilation, reduces memory allocation overhead
	* Cons: Requires more memory allocation, might not perform as well on very large strings with many edge cases
4. **Slice()**: This approach creates a new string by taking a slice of the original string. It's similar to `substring()` but uses a different implementation.
	* Pros: Fast and simple, avoids creating temporary string objects
	* Cons: Can be slower due to memory allocation overhead (similar to substring())

**Library Usage**

The benchmark uses the `regex` object to create compiled regular expressions. The `regex` object is a built-in JavaScript object that provides methods for working with regular expressions.

In the `replace()` tests, the `regex` variable is used as a pattern to match against. This allows the test to handle edge cases and replace characters in different ways.

**Special JS Feature/Syntax**

There are no special JS features or syntax used in this benchmark. The tests focus on comparing the performance of different string replacement approaches.

**Other Alternatives**

If you were to create a similar benchmark, you might also consider testing other string replacement approaches, such as:

* Using `String.prototype.replace()` with a callback function
* Using `String.prototype.replace()` with a custom replacer function
* Using a library like Lodash or Ramda for string manipulation

Keep in mind that the performance differences between these approaches can be significant, especially on very large strings. When choosing an approach, consider factors such as memory allocation overhead, caching, and the specific use case requirements.

replace vs substring vs slice from END (version: 0)

Comparing performance of: substring vs replace inline regex vs replace compiled regex var vs slice

Created: 3 years ago by: Guest

Go to the latest result

substring

replace inline regex

replace compiled regex var

slice

Historical Performance Data aggregated from 77 community runs

Desktop Results:

Chrome 58 runs

Firefox 19 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: `substring vs replace inline regex vs replace compiled regex var vs slice`