Benchmark: slice vs subarray vs set custom

Script Preparation code:

var data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var u8 = new Uint8Array(data);

Tests:

subarray direct
var copy = u8.subarray(10, 20);
slice direct
var copy = u8.slice(10, 20);
subarray copy
var copy = new Uint8Array(u8.subarray(10, 20));
slice copy
var copy = new Uint8Array(u8.slice(10, 20));
subarray set
var copy = new Uint8Array(10).set(u8.subarray(10, 20));
slice set
var copy = new Uint8Array(10).set(u8.slice(10, 20));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
subarray direct
slice direct
subarray copy
slice copy
subarray set
slice set

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 10 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:133.0) Gecko/20100101 Firefox/133.0

Browser/OS: Firefox 133 on Windows

View result in a separate tab

Test name	Executions per second
subarray direct	8049036.0 Ops/sec
slice direct	10980891.0 Ops/sec
subarray copy	4609577.5 Ops/sec
slice copy	5763703.5 Ops/sec
subarray set	6263372.0 Ops/sec
slice set	7807001.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of different approaches to create a subset or copy of an array is crucial in understanding how JavaScript engines optimize array operations.

The benchmark tests four different ways to create a subset of an array:

1. **Subarray**: Creating a new array using `subarray(start, end)` method.
2. **Slice**: Creating a new array using `slice(start, end)` method.
3. **Copy**: Creating a new array by copying the elements from the original array using `new Uint8Array()` and then setting the values using `set()`.
4. **Set**: Creating a new array by initializing it with the desired length and then setting its values.

Let's analyze each approach:

**Subarray and Slice**:
These two methods are similar, as they both return a new array containing the elements from the original array, starting at the specified index `start` and ending at `end`. However, there is a subtle difference between them. When using `slice()`, the method returns an object with `length` property equal to `end - start`, whereas `subarray()` returns an object with `length` equal to `end - start + 1`. This means that if you're sure about the length of the subset, `slice()` is faster. If you're not sure, `subarray()` might be a better choice.

**Copy and Set**:
Creating a new array by copying elements from an original array using `new Uint8Array()` and then setting its values is generally slower than creating an array with `slice()` or `subarray()`. However, this approach can be beneficial when you need to create an exact copy of the original array without modifying it.

**Performance Comparison**:
According to the latest benchmark results, the order of performance from fastest to slowest is:

1. **Slice direct**: 6275196.5 executions per second
2. **Subarray direct**: 6794308.0 executions per second
3. **Slice copy**: 3125990.75 executions per second
4. **Subarray copy**: 3266891.0 executions per second
5. **Set custom**: 2927842.75 executions per second
6. **Set direct**: (not shown in the results)

**Other Considerations**:

* Using `Array.prototype.slice()` or `Array.prototype.subarray()` can be faster than using `Array.prototype.slice.call()`, as it avoids creating an intermediate object.
* When working with large arrays, you might want to consider using WebAssembly for better performance.

In summary, when measuring the performance of different approaches to create a subset of an array, it's essential to understand the differences between `slice()` and `subarray()`. Creating a new array by copying elements from the original array using `new Uint8Array()` and then setting its values is generally slower than using `slice()` or `subarray()`, but can be beneficial when you need an exact copy.

Related benchmarks:

slice vs subarray vs set custom (version: 0)

Comparing performance of: subarray direct vs slice direct vs subarray copy vs slice copy vs subarray set vs slice set

Created: 3 years ago by: Guest

Jump to the latest result

subarray direct

slice direct

subarray copy

slice copy

subarray set

slice set

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