Benchmark: Performance Test: substring + indexOf x split + splice x split + [0] x regex multiple

Script Preparation code:

var str = "I am the god of hellfire, and I bring you_01"
var str1 = "ayou_01"
var str2 = "tesaasyou_01"
var str3 = "1_01"

Tests:

substring
const test = str.substring( 0 ,str.indexOf('_')); const test1 = str1.substring( 0 ,str.indexOf('_')); const test2 = str2.substring( 0 ,str.indexOf('_')); const test3 = str3.substring( 0 ,str.indexOf('_'));
split splice
const test = str.split('_').splice(0,1)[0]; const test1 = str1.split('_').splice(0,1)[0]; const test2 = str2.split('_').splice(0,1)[0]; const test3 = str3.split('_').splice(0,1)[0];
split [0]
const test = str.split('_')[0]; const test1 = str1.split('_')[0]; const test2 = str2.split('_')[0]; const test3 = str3.split('_')[0];
match
const test = str.match(/([\s\S]*)_/)[1]; const test1 = str1.match(/([\s\S]*)_/)[1]; const test2 = str2.match(/([\s\S]*)_/)[1]; const test3 = str3.match(/([\s\S]*)_/)[1];

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
substring
split splice
split [0]
match

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 92 on Linux

View result in a separate tab

Test name	Executions per second
substring	1585802.4 Ops/sec
split splice	826205.4 Ops/sec
split [0]	1113431.9 Ops/sec
match	1171575.8 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark JSON and explain what's being tested.

**Benchmark Overview**

The test cases compare different approaches to extract a specific substring or split a string in JavaScript. The goal is to measure the performance of these operations across various browsers and devices.

**Test Cases**

There are four test cases, each with its own benchmark definition:

1. **substring**: Extracts the substring before the first underscore (`_`) from the input strings `str`, `str1`, `str2`, and `str3`.
2. **split splice**: Splits the string into an array using the underscore character as a delimiter, removes the first element of the resulting array, and extracts it.
3. **split [0]**: Similar to the previous test case, but uses square brackets (`[]`) instead of the `splice` method to extract the first element of the split array.
4. **match**: Uses regular expressions to match the string against a pattern that captures one or more whitespace characters followed by an underscore. The matched substring is extracted and returned.

**Library/Functionality Used**

None of the test cases use any external libraries, but rather rely on built-in JavaScript functions:

* `str.substring()`
* `str.split()`
* `Array.splice()` (used in `split splice` and `split [0]`)
* `String.match()` (used in `match`)

**Special JS Features/Syntax**

The test cases use regular expressions (`/([^\\s]+)_/)`) in the `match` test case, which is a feature introduced in ECMAScript 5.

**Approaches Compared**

The four approaches are compared in terms of their performance:

* **substring**: A simple and straightforward approach that extracts the substring before the first underscore.
* **split splice**: Uses the `splice()` method to remove the first element of the split array, which may introduce additional overhead due to the dynamic nature of array indexing.
* **split [0]**: Similar to `split splice`, but uses square brackets (`[]`) instead of the `splice` method. This approach is likely to be faster since it avoids the dynamic indexing overhead.
* **match**: Uses regular expressions to extract the substring, which may introduce additional overhead due to the complexity of the pattern.

**Pros and Cons**

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

* **substring**: Pros: Simple and straightforward; Cons: May not be optimized for performance.
* **split splice**: Pros: None significant; Cons: Dynamic indexing can lead to overhead.
* **split [0]**: Pros: Faster than `split splice` due to reduced dynamic indexing; Cons: May require additional effort to implement correctly.
* **match**: Pros: None significant; Cons: Regular expressions can introduce additional overhead.

**Other Alternatives**

If you need to perform substring or split operations, other alternatives include:

* Using the `indexOf()` method instead of `substring()`
* Using a loop to iterate over the split array instead of indexing
* Using a different regular expression pattern or approach in the `match` test case

Keep in mind that these alternative approaches may have different performance characteristics and trade-offs.

Related benchmarks:

Performance Test: substring + indexOf x split + splice x split + [0] x regex multiple (version: 1)

Comparing performance of: substring vs split splice vs split [0] vs match

Created: 4 years ago by: Registered User

Jump to the latest result

substring

split splice

split [0]

match

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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