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: 3 years ago by: Registered User

Go 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) })

Historical Performance Data aggregated from 7 community runs

Desktop Results:

Chrome 7 runs

Using String.slice()

879/s

Using String.slice() without a pre-calculated suffix length

872/s

Using String.substring() with a magic number

868/s

Using String.substring() with a lastIndexOf() search

361/s

Using String.replace()

302/s

Fastest: Using String.slice() (2.9x faster)

View exact numbers

✓ Using String.slice(): 879 ops/sec
• Using String.slice() without a pre-calculated suffix length: 872 ops/sec
• Using String.substring() with a magic number: 868 ops/sec
• Using String.substring() with a lastIndexOf() search: 361 ops/sec
• Using String.replace(): 302 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
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: 28 days ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:152.0) Gecko/20100101 Firefox/152.0

Browser/OS: Firefox 152 on Mac OS X 10.15

View result in a separate tab

Using String.replace()

125/s

Using String.substring() with a magic number

97/s

Using String.substring() with a lastIndexOf() search

95/s

Using String.slice() without a pre-calculated suffix length

31/s

Using String.slice()

29/s

View exact numbers

Test name	Executions per second
✓ Using String.replace()	125 Ops/sec
Using String.substring() with a magic number	97 Ops/sec
Using String.substring() with a lastIndexOf() search	95 Ops/sec
Using String.slice() without a pre-calculated suffix length	31 Ops/sec
Using String.slice()	29 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.

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: 3 years ago by: Registered User

Go to the latest 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

Historical Performance Data aggregated from 7 community runs

Desktop Results:

Chrome 7 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: `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`