Benchmark: Array.prototype.concat vs spread operator - Immutable version

HTML Preparation code:


<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

var array1 = (new Array(10000)).fill(Math.random(), 0, 9999);
var array2 = (new Array(10000)).fill(Math.random(), 0, 9999);

Tests:

Array.prototype.concat
var other = array1.concat(array2);
spread operator
var other = [ ...array1, ...array2 ]
Lodash merge
var other = _.merge([], array1, array2);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.prototype.concat
spread operator
Lodash merge

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark.

**What is tested?**

The benchmark tests three different approaches to concatenate two arrays:

1. `Array.prototype.concat()`: The traditional method for concatenating arrays in JavaScript.
2. Spread operator (`...`): The new ES6 syntax for spreading array elements into a new array.
3. Lodash's `merge()` function: A utility function from the popular JavaScript library Lodash that merges two or more arrays into one.

**Options compared**

The benchmark compares these three approaches on an immutable data requirement, creating fresh arrays for each case.

**Pros and Cons of each approach**

1. **`Array.prototype.concat()`**:
	* Pros: Simple, widely supported, and has been the standard way to concatenate arrays in JavaScript for a long time.
	* Cons: Creates a new array, which can lead to performance issues if dealing with large datasets or when memory is limited.
2. **Spread operator (`...`)**
	* Pros: Creates a shallow copy of the original array, which is more efficient than `concat()` for large arrays. Also, it's a concise and expressive way to concatenate arrays.
	* Cons: Requires modern JavaScript versions (ES6+) and may not work in older browsers or environments that don't support ES6 syntax.
3. **Lodash's `merge()` function**:
	* Pros: Provides a standardized and efficient way to merge arrays, which can be useful in various use cases. It also offers more features than just concatenation, such as merging objects.
	* Cons: Requires including the Lodash library in your project, which may add unnecessary size and complexity.

**Library and purpose**

Lodash is a popular JavaScript utility library that provides a comprehensive set of functions for various tasks, such as array manipulation, string manipulation, and more. The `merge()` function in particular is designed to merge two or more arrays into one, handling edge cases like null or undefined values.

**Special JS feature or syntax**

There's no specific special JS feature or syntax used in this benchmark apart from the use of ES6 spread operator (`...`), which requires modern JavaScript versions. However, it's worth noting that Lodash is a popular library and using its functions can provide a standardized way to perform common tasks.

**Other alternatives**

If you don't want to use the spread operator or Lodash's `merge()` function, you could consider other approaches:

* Using the `concat()` method with a loop: `var other = []; while (array1.length > 0) { other.push(array1.shift()); if (array2.length > 0) { other.push(array2.shift()); } }`
* Using array literals and `push()`: `var other = [array1, array2];`

However, these alternatives are generally less efficient than the spread operator or Lodash's `merge()` function.

In summary, the benchmark provides a useful comparison of three approaches to concatenate arrays in JavaScript: traditional `concat()`, modern spread operator, and standardized Lodash `merge()` function.

Latest run results:

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

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

Browser/OS: Firefox 79 on Windows

View result in a separate tab

Test name	Executions per second
Array.prototype.concat	2990.7 Ops/sec
spread operator	2668.6 Ops/sec
Lodash merge	213.4 Ops/sec

Related benchmarks:

Array.prototype.concat vs spread operator - Immutable version (version: 0)

Compare the new ES6 spread operator with the traditional concat() method. All methods create a fresh array to simulate an environment where immutable data is a requirement.

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

Created: 6 years ago by: Guest

Jump to the latest result

Array.prototype.concat

spread operator

Lodash merge

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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