Benchmark: Array.split vs string.substring

Script Preparation code:

var s1 = "en-us";
var s2 = "en";

Tests:

Array.split
var n1 = s1.split("-")[0]; var n2 = s2.split("-")[0];
Substring
var n1 = s1.substring(0, 2); var n2 = s2.substring(0, 2);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.split
Substring

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.80 Safari/537.36

Browser/OS: Chrome 86 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Array.split	2142330.0 Ops/sec
Substring	7433103.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of the provided benchmark.

**What is being tested?**

The provided JSON represents a JavaScript microbenchmark that compares two approaches to extract a specific substring from a string: `Array.split()` and `string.substring()`. The test case uses two strings, `s1` and `s2`, which contain a hyphen (`-`) character. The goal is to extract the first part of the string before the hyphen.

**Options being compared**

The two options being compared are:

1. **Array.split()**: This method splits an array (in this case, a single-element array containing the original string) into an array of substrings using a specified separator (in this case, a hyphen).
2. **string.substring()**: This method returns a new string that includes all characters from the beginning of the original string up to, but not including, the specified index.

**Pros and Cons**

* **Array.split()**:
	+ Pros: Can be faster for large strings because it avoids the overhead of iterating over each character.
	+ Cons: Requires an extra array operation and can lead to slower performance if the separator is not present in the string.
* **string.substring()**:
	+ Pros: More straightforward and readable, as it directly extracts a substring without creating intermediate arrays.
	+ Cons: May be slower for large strings due to the overhead of iterating over each character.

**Library usage**

There is no explicit library used in this benchmark. However, some browsers might use internal libraries or optimizations that could affect the results.

**Special JS feature or syntax**

None are mentioned in this specific benchmark.

**Other alternatives**

While not explicitly tested in this benchmark, other approaches to extract a substring from a string include:

1. **Regex**: Using regular expressions can be fast but may require more effort to set up and optimize.
2. **String.prototype.replace()**: Replacing the first occurrence of the separator with an empty string can achieve similar results to `substring()`.

**Benchmark preparation code**

The provided script preparation code:
```javascript
var s1 = "en-us";
var s2 = "en";
```
Defines two strings, `s1` and `s2`, which will be used as input for the benchmark.

**Individual test cases**

There are two individual test cases:

1. **Array.split()**: Extracts the first part of `s1` using `Array.split()`.
2. **Substring()**: Extracts the first part of `s2` using `string.substring()`.

The latest benchmark result shows that the "Substring" approach performed better in terms of executions per second on a specific device and browser configuration.

Related benchmarks:

Array.split vs string.substring (version: 0)

Comparing performance of: Array.split vs Substring

Created: 4 years ago by: Registered User

Jump to the latest result

Array.split

Substring

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