Benchmark: substring vs. slice vs. replace to remove string from end of input string

substring vs. slice vs. replace to remove string from end of input string (version: 3)

Determine the fastest way to remove a string from the end of another string.

Comparing performance of: Using String.replace() vs Using String.substring() with a lastIndexOf() search vs Using String.substring() with a magic number vs Using String.slice() vs Using String.slice() without a pre-calculated suffix length

Created: 2 years ago by: Registered User

Jump to the latest result

Script Preparation code:

var numOfStrings = 100000
var suffix = 'TestStringHere'
var suffixLength = suffix.length
var negSuffixLength = suffixLength * -1
var testStrings = []

// Generate test string as a UUID + the suffix above.
function uuidv4() {
   return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g,
   function(c) {
      var uuid = Math.random() * 16 | 0, v = c == 'x' ? uuid : (uuid & 0x3 | 0x8);
      return uuid.toString(16);
   });
}

for (let i = 0; i < numOfStrings; i++) {
  testStrings.push(uuidv4() + suffix)
}

Tests:

Using String.replace()
testStrings.map(str => { return str.replace(suffix, '') })
Using String.substring() with a lastIndexOf() search
testStrings.map(str => { return str.substring(0, str.lastIndexOf(suffix)) })
Using String.substring() with a magic number
testStrings.map(str => { return str.substring(0, str.length - suffixLength) })
Using String.slice()
testStrings.map(str => { return str.slice(0, negSuffixLength) })
Using String.slice() without a pre-calculated suffix length
testStrings.map(str => { return str.slice(0, suffix.length * -1) })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Using String.replace()
Using String.substring() with a lastIndexOf() search
Using String.substring() with a magic number
Using String.slice()
Using String.slice() without a pre-calculated suffix length

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/145.0.0.0 Safari/537.36

Browser/OS: Chrome 145 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Using String.replace()	301.9 Ops/sec
Using String.substring() with a lastIndexOf() search	361.3 Ops/sec
Using String.substring() with a magic number	867.8 Ops/sec
Using String.slice()	878.7 Ops/sec
Using String.slice() without a pre-calculated suffix length	871.6 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 benchmark and explain what's being tested.

**Benchmark Definition**

The benchmark is designed to compare four different approaches for removing a string from the end of another string:

1. `String.replace()`
2. `String.substring()` with a lastIndexOf() search
3. `String.substring()` with a magic number (i.e., a hardcoded value)
4. `String.slice()`

**Options Compared**

The benchmark is testing the performance of each approach on a large dataset of strings, where each string has a unique suffix appended to it.

* The four approaches are being compared in terms of execution speed, measured in executions per second.
* Each approach is executed on the same dataset of 100,000 test strings.
* The dataset consists of UUID-generated strings with a fixed suffix ("TestStringHere").

**Pros and Cons**

Here's a brief analysis of each approach:

1. **`String.replace()`**: This method is simple and efficient, as it directly replaces the suffix with an empty string. However, it may incur additional overhead due to the replacement operation.
	* Pros: Simple and efficient
	* Cons: May incur extra overhead
2. **`String.substring()` with lastIndexOf() search**: This approach uses the `lastIndexOf()` method to find the position of the suffix in the original string, and then extracts the substring up to that point.
	* Pros: Avoids magic numbers and is more accurate than using a hardcoded value
	* Cons: May be slower due to the additional operation
3. **`String.substring()` with a magic number**: This approach uses a hardcoded value (the length of the suffix) to determine the start index for extraction.
	* Pros: Simple and fast, as it avoids extra operations
	* Cons: May not work correctly if the suffix length changes
4. **`String.slice()`**: This method is similar to `substring()`, but uses a more efficient implementation under the hood.
	* Pros: Fast and efficient, with less overhead than `replace()`
	* Cons: May be slower for very large strings or complex substrings

**Library Used**

None of these approaches rely on any external libraries.

**Special JS Features/Syntax**

The benchmark does not use any special JavaScript features or syntax beyond the standard ECMAScript 2020 specification. The focus is on comparing the performance of different string manipulation techniques.

**Other Alternatives**

If you're interested in exploring alternative approaches, some options to consider are:

* Using a regex replacement with `String.prototype.replace()` (e.g., `str.replace(new RegExp(suffix + '$'), '')`)
* Using a custom implementation of the substring or slice methods
* Employing a more advanced string manipulation library or framework (e.g., RegEx, String.prototype.match() / exec())

Keep in mind that these alternatives may not be optimized for performance and should be tested separately to ensure their suitability for your specific use case.

Related benchmarks: