Benchmark: Array.prototype.concat vs spread operator number 2

Tests:

Array.prototype.concat
var params = [ "hello", true, 7 ]; var old = [1,2]; var other = [...old, ...params];
spread operator
var params = [ "hello", true, 7 ]; var old = [1,2]; var other = old.concat(params);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.prototype.concat
spread operator

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Firefox 75 on Ubuntu

View result in a separate tab

Test name	Executions per second
Array.prototype.concat	9252270.0 Ops/sec
spread operator	9672811.0 Ops/sec

Autogenerated LLM Summary (model llama3.1:latest, generated one month ago):

LLMs can make mistakes. Check important info.

Let's dive into the explanation.

**Benchmark Definition**

The benchmark is called "Array.prototype.concat vs spread operator number 2", which means it's comparing two different ways of concatenating arrays in JavaScript: `Array.prototype.concat()` and the spread operator (`...`).

**Individual Test Cases**

There are two test cases:

1. **"Array.prototype.concat"**: This test case uses the traditional `concat()` method to concatenate two arrays: `[1, 2]` and `["hello", true, 7]`.
2. **"spread operator"**: This test case uses the spread operator (`...`) to concatenate the same two arrays.

**Library or Special JS Feature/Syntax**

There are no external libraries used in this benchmark. The only special JavaScript feature used is the spread operator (`...`), which was introduced in ECMAScript 2015 (ES6).

The spread operator allows you to expand an array into a new one, like this: `[1, 2]` becomes `"...[1, 2]"` without the quotes. This syntax is equivalent to using `concat()`.

**Pros and Cons**

Here's a brief comparison of the two approaches:

* **Array.prototype.concat()**: This method is more traditional and widely supported in older browsers. However, it can be slower than the spread operator for large arrays.
* **Spread Operator (`...`)**: This syntax is newer and more concise. It's faster than `concat()` for large arrays, but may have issues with older browsers that don't support ES6.

**Other Alternatives**

Besides these two approaches, there are other ways to concatenate arrays in JavaScript:

* **Pushing elements individually**: You can use a loop to add each element from one array to another.
* **Using the `push()` method with an array of arrays**: This approach is less efficient but can be useful for specific use cases.

**Benchmark Result**

The latest benchmark result shows that the spread operator outperforms `concat()` by a small margin (about 4.5%) on this particular test case, using Firefox 75 as the browser.

Keep in mind that these results are based on a specific test case and might not generalize to all scenarios. The actual performance difference may vary depending on your use case and JavaScript engine.

Related benchmarks:

Array.prototype.concat vs spread operator number 2 (version: 0)

Compare the new ES6 spread operator with the traditional concat() method

Comparing performance of: Array.prototype.concat vs spread operator

Created: 4 years ago by: Guest

Jump to the latest result

Array.prototype.concat

spread operator

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.1:latest, generated one month ago):