Benchmark: _substring vs slice

Script Preparation code:

var s = "Long line of text, including different characters and numebrs like 1 - 2_3*4/5 and it is not stopping yet, keeps going to the limits...";

Tests:

slice
var r = s.slice(62, 66);
substring
var r = s.substring(62, 66);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
slice
substring

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:121.0) Gecko/20100101 Firefox/121.0

Browser/OS: Firefox 121 on Ubuntu

View result in a separate tab

Test name	Executions per second
slice	1287219584.0 Ops/sec
substring	1343893376.0 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 world of JavaScript microbenchmarks on MeasureThat.net.

The benchmark being tested is the performance difference between two methods: `slice()` and `substring()`. Both methods are used to extract a subset of characters from a string, but they have some subtle differences in their implementation.

**What options are compared?**

The two options being compared are:

1. `s.slice(62, 66)`
2. `s.substring(62, 66)`

**Pros and Cons:**

* `slice()`: This method returns a new string object containing the characters after index 62 up to (but not including) index 66.
	+ Pros:
		- More flexible, as it can be used to create strings with a specified length and offset.
		- Can be used to split strings into multiple parts.
	+ Cons:
		- Creates a new string object, which can lead to increased memory usage.
* `substring()`: This method returns a new string object containing the characters from index 62 up to (but not including) index 66.
	+ Pros:
		- Also creates a new string object, but with less overhead than `slice()` since it doesn't require specifying the length.
	+ Cons:
		- Less flexible than `slice()`, as it only returns a substring of the original string.

**Library and Purpose:**

There are no libraries involved in this benchmark. However, it's worth noting that both `slice()` and `substring()` are part of the JavaScript Standard Library.

**Special JS feature or syntax:**

None mentioned. These methods are standard JavaScript functions.

**Benchmark preparation code:**

The script preparation code is:
```javascript
var s = "Long line of text, including different characters and numbers like 1 - 2_3*4/5 and it is not stopping yet, keeps going to the limits...";
```
This creates a long string `s` with various characters, numbers, and punctuation. The length of this string is approximately 66 characters.

**Individual test cases:**

The two test cases are:

1. `slice()`: Extracts a subset of characters from index 62 to 66 using the `slice()` method.
2. `substring()`: Extracts a subset of characters from index 62 to 66 using the `substring()` method.

**Latest benchmark result:**

The latest results show that `substring()` performs slightly better than `slice()`, with an execution rate of approximately 128 million executions per second compared to 134 million for `slice()`.

**Other alternatives:**

If you need to extract a subset of characters from a string, you may also consider using other methods such as:

* Using regular expressions (regex) to match and extract specific patterns.
* Using array manipulation techniques, such as slicing or splicing arrays.
* Using libraries like Lodash or Ramda for functional programming approaches.

However, for this specific benchmark, `slice()` and `substring()` are the most straightforward and efficient options.

Related benchmarks:

_substring vs slice (version: 0)

Comparing performance of: slice vs substring

Created: 2 years ago by: Guest

Jump to the latest result

slice

substring

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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