Benchmark: substring vs split vs slice

Script Preparation code:

var testString = "<this is the first string>and this is the second string";

Tests:

substring
var firstString = testString.substring(1,24); var secondString = testString.substring(26);
split
var splitArray = testString.split('<')[1].split('>'); var firstString = splitArray[0]; var secondString = splitArray[1];
slice
var firstString = testString.slice(1,24); var secondString = testString.slice(26);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
substring
split
slice

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/98.0.4758.87 Safari/537.36

Browser/OS: Chrome 98 on Windows

View result in a separate tab

Test name	Executions per second
substring	5463083.0 Ops/sec
split	2588543.5 Ops/sec
slice	5500284.0 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 benchmark and its test cases.

**Benchmark Purpose**
The benchmark compares the performance of three different approaches to extract substrings from a given string:

1. `substring()`
2. `split()` (with `<>` delimiters)
3. `slice()`

**Options Compared**

*   **`substring(start, length)`**: extracts a contiguous portion of a string.
    *   Pros: flexible, can be used to extract arbitrary substrings.
    *   Cons: slower than other methods for large or contiguous substrings, requires specifying both start and end indices.
*   **`split(delimiter)`**: splits a string into an array of substrings using a specified delimiter. If the delimiter is not found, returns an array containing the original string.
    *   Pros: easy to use, can be used for non-contiguous substrings.
    *   Cons: slower than `slice()` and may create unnecessary intermediate arrays.
*   **`slice(start, length)`**: extracts a portion of a string.
    *   Pros: efficient, flexible (uses the same syntax as `substring()`), and modern browsers support it well.
    *   Cons: not supported in older browsers or those with very limited JavaScript capabilities.

**Library Used**
None, only standard JavaScript functions are used.

**Special JS Feature/Syntax**
`slice()` is a modern JavaScript function introduced in ECMAScript 5 (ES5). It's widely supported in modern browsers and Node.js environments. However, its usage might not be compatible with older browsers or those that don't support ES5.

In contrast, `substring()` and `split()` are standard JavaScript methods available in all browsers since at least Netscape Navigator 4.

**Other Alternatives**

*   **`substr(start, length)`**: similar to `slice()`, but can return null if the start index is negative.
*   **`indexOf(delimiter) + length`: concatenation of `indexOf()` and `length`. This can be used for splitting a string by finding the first occurrence of the delimiter and then extracting a substring. However, it's generally slower than `split()`.
*   **Regexp methods** (e.g., `RegExp.prototype.exec()`, `RegExp.prototype.test()`): These can also be used to split or extract substrings from strings, but they are more complex to use and might not provide the same level of performance as `slice()`.

In summary, when it comes to extracting substrings from a string in JavaScript, modern browsers support `slice()`, which is an efficient choice. Older browsers may require using either `substring()` or `split()`. It's essential to consider the target audience and desired feature set when choosing between these methods.

Related benchmarks:

substring vs split vs slice (version: 0)

Comparing performance of: substring vs split vs slice

Created: 2 years ago by: Guest

Jump to the latest result

substring

split

slice

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):