Benchmark: replace vs substring vs slice from beginning (+ brackets, substr, compiled vs inline regex)

replace vs substring vs slice from beginning (+ brackets, substr, compiled vs inline regex) (version: 1)

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 and substring vs replace inline regex vs replace compiled regex var vs brackets and substring vs brackets and slice vs substring and slice vs brackets and substr (legacy) vs substr and substr (legacy)`

Created: 7 years ago by: Registered User

Go to the latest result

Script Preparation code:

var strIn = '?this=a+test&that=just+it';
var strOut = '';
var regex = /^\?/;

Tests:

substring and substring
strOut = strIn.substring(0,1) === '?' ? strIn.substring(1) : strIn;
replace inline regex
strOut = strIn.replace(/^\?/, '');
replace compiled regex var
strOut = strIn.replace(regex, '');
brackets and substring
strOut = strIn[0] === '?' ? strIn.substring(1) : strIn;
brackets and slice
strOut = strIn[0] === '?' ? strIn.slice(1) : strIn;
substring and slice
strOut = strIn.substring(0,1) === '?' ? strIn.slice(1) : strIn;
brackets and substr (legacy)
strOut = strIn[0] === '?' ? strIn.substr(1) : strIn;
substr and substr (legacy)
strOut = strIn.substr(0,1) === '?' ? strIn.substr(1) : strIn;

Historical Performance Data aggregated from 28 community runs

Desktop Results:

Chrome 28 runs

replace inline regex

6.9M/s

brackets and substr (legacy)

6.3M/s

brackets and slice

6.3M/s

substr and substr (legacy)

6.3M/s

brackets and substring

6.3M/s

substring and slice

6.2M/s

substring and substring

6.2M/s

replace compiled regex var

5.2M/s

Fastest: replace inline regex (1.3x faster)

View exact numbers

✓ replace inline regex: 6,888,864 ops/sec
• brackets and substr (legacy): 6,306,034 ops/sec
• brackets and slice: 6,284,784 ops/sec
• substr and substr (legacy): 6,273,526 ops/sec
• brackets and substring: 6,262,888 ops/sec
• substring and slice: 6,245,935 ops/sec
• substring and substring: 6,201,074 ops/sec
• replace compiled regex var: 5,189,778 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 and substring
replace inline regex
replace compiled regex var
brackets and substring
brackets and slice
substring and slice
brackets and substr (legacy)
substr and substr (legacy)

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 YaBrowser/25.8.0.0 Safari/537.36

Browser/OS: Yandex Browser 25 on Linux

View result in a separate tab

brackets and substring

9.6M/s

substring and slice

9.0M/s

substring and substring

9.0M/s

brackets and substr (legacy)

9.0M/s

brackets and slice

8.9M/s

substr and substr (legacy)

8.7M/s

replace compiled regex var

6.7M/s

replace inline regex

6.4M/s

View exact numbers

Test name	Executions per second
✓ brackets and substring	9,635,666 Ops/sec
substring and slice	9,036,284 Ops/sec
substring and substring	8,957,487 Ops/sec
brackets and substr (legacy)	8,950,256 Ops/sec
brackets and slice	8,878,268 Ops/sec
substr and substr (legacy)	8,680,502 Ops/sec
replace compiled regex var	6,666,793 Ops/sec
replace inline regex	6,367,285 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of different string manipulation methods in JavaScript is crucial for optimizing code and improving application performance.

The provided benchmark tests four common methods to replace or extract characters from the beginning of a string:

1. `substring()`
2. `replace()` with inline regular expressions
3. `replace()` with compiled regular expressions
4. Bracket notation (`[]`)

Let's analyze each method, their pros and cons, and other considerations.

**1. substring()**

Pros:
	* Simple to use and implement.
	* Works well for smaller strings.

Cons:
	* Slow performance for large strings due to the need to create a new string object.
	* Can lead to memory issues if not used carefully.

Considerations:
	* `substring()` is generally slower than other methods because it creates a new string object. However, its simplicity and ease of use make it a popular choice.

**2. replace() with inline regular expressions**

Pros:
	* Fast performance for large strings using regular expressions.
	* Can be more efficient than `substring()` due to the optimized engine used by modern browsers.

Cons:
	* Requires careful handling of edge cases, such as when the input string is empty or null.
	* May be slower for very short strings due to the overhead of compiling regular expressions.

Considerations:
	* Using inline regular expressions can provide a performance boost compared to `substring()`, especially for large inputs. However, it requires proper handling of edge cases and may be overkill for short strings.

**3. replace() with compiled regular expressions**

Pros:
	* Can provide faster performance than inline regular expressions due to the compilation step.
	* Allows for more complex patterns and easier maintenance.

Cons:
	* May introduce additional overhead due to the compilation process.
	* Requires careful handling of edge cases, such as when the input string is empty or null.

Considerations:
	* Compiled regular expressions can offer better performance than inline regular expressions but may add unnecessary complexity. The trade-off depends on the specific use case and optimization goals.

**4. Bracket notation ([])**

Pros:
	* Fast performance due to optimized engine support.
	* Can be more efficient than `substring()` for very short strings.

Cons:
	* Less readable and maintainable code compared to other methods.
	* May not work as expected in some edge cases, such as when the input string is empty or null.

Considerations:
	* Bracket notation can provide a performance boost compared to `substring()`, especially for very short strings. However, its lack of readability and potential issues with edge cases make it less desirable.

In conclusion, the choice of string manipulation method depends on the specific requirements of your project, such as performance, code readability, and maintainability. Understanding the pros and cons of each method will help you optimize your code for maximum efficiency.

Looking at the benchmark results, we can see that:

* `replace()` with inline regular expressions provides the best performance for large strings.
* Bracket notation offers fast performance for very short strings.
* Compiled regular expressions provide a good balance between performance and maintainability.
* `substring()` is generally slower but simpler to use.

Keep in mind that these results are specific to this benchmark and may vary depending on your specific use case and optimization goals.

replace vs substring vs slice from beginning (+ brackets, substr, compiled vs inline regex) (version: 1)

Comparing performance of: substring and substring vs replace inline regex vs replace compiled regex var vs brackets and substring vs brackets and slice vs substring and slice vs brackets and substr (legacy) vs substr and substr (legacy)

Created: 7 years ago by: Registered User

Go to the latest result

substring and substring

replace inline regex

replace compiled regex var

brackets and substring

brackets and slice

substring and slice

brackets and substr (legacy)

substr and substr (legacy)

Historical Performance Data aggregated from 28 community runs

Desktop Results:

Chrome 28 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 and substring vs replace inline regex vs replace compiled regex var vs brackets and substring vs brackets and slice vs substring and slice vs brackets and substr (legacy) vs substr and substr (legacy)`