Benchmark: concat vs lodash.concat vs. push.apply vs. spread operator vs. push in for loop 1

HTML Preparation code:

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

Script Preparation code:

var arr1 = ["what", "is", "this"];
var arr2 = ["this", "is", "a", "test", "hello", "how", "are", "you", "today"];

Tests:

Array.prototype.concat
var result = arr1.concat(arr2);
Lodash concat
var result = _.concat(arr1, arr2);
Array.prototype.push.apply()
Array.prototype.push.apply(arr1, arr2);
spread operator
var result = [...arr1, ...arr2]
cached for + push
for (var i = 0, l = arr2.length; i < l; i++) { arr1.push(arr2[i]) }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.prototype.concat
Lodash concat
Array.prototype.push.apply()
spread operator
cached for + push

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested in this benchmark.

**Benchmark Overview**

The test compares the performance of four different approaches to concatenate two arrays:

1. `Array.prototype.concat()`
2. Using the Lodash library (`_concat`)
3. `Array.prototype.push.apply()`
4. The spread operator (`...`)

**Test Case Analysis**

Each test case has a simple benchmark definition, which consists of a single line of JavaScript code that concatenates two arrays using one of the above approaches.

Here's a brief explanation of each approach:

1. **`Array.prototype.concat()`**: This method creates a new array by copying all elements from both input arrays.
2. **Lodash (`_concat`)**: Lodash is a utility library that provides various functions, including `concat`. This approach uses the Lodash library to concatenate the two arrays.
3. **`Array.prototype.push.apply()`**: This method adds all elements of an array (or an iterable) to another array, modifying the original array.
4. **Spread Operator (`...`)**: The spread operator is a new feature introduced in ECMAScript 2015 that allows you to create a new array by spreading the elements of an existing array.

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

1. **`Array.prototype.concat()`**:
	* Pros: Fast, straightforward.
	* Cons: Creates a new array, which can be memory-intensive for large inputs.
2. **Lodash (`_concat`)**:
	* Pros: Easy to use, flexible, and customizable.
	* Cons: Requires an external library, adds overhead.
3. **`Array.prototype.push.apply()`**:
	* Pros: Efficient for small inputs, modifies original array.
	* Cons: Can be slower for large inputs due to the `push` method's behavior.
4. **Spread Operator (`...`)**:
	* Pros: Fast, concise, and modern.
	* Cons: Only available in modern browsers and Node.js.

**Library Considerations**

In this benchmark, Lodash is used as a library to provide an alternative implementation of the concatenation function. This allows developers to compare the performance of different approaches without relying on specific browser or platform optimizations.

**Special Features and Syntax**

The spread operator (`...`) was introduced in ECMAScript 2015, which means it's not supported in older browsers or versions of JavaScript. The test result for the spread operator is likely running in a modern browser or Node.js environment that supports this feature.

If you're interested in understanding more about JavaScript features and syntax, I can provide guidance on other topics!

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Firefox 110 on Windows

View result in a separate tab

Test name	Executions per second
Array.prototype.concat	9017444.0 Ops/sec
Lodash concat	3269537.5 Ops/sec
Array.prototype.push.apply()	2262126.5 Ops/sec
spread operator	0.2 Ops/sec
cached for + push	1720424.1 Ops/sec

Related benchmarks:

concat vs lodash.concat vs. push.apply vs. spread operator vs. push in for loop 1 (version: 0)

Comparing performance of: Array.prototype.concat vs Lodash concat vs Array.prototype.push.apply() vs spread operator vs cached for + push

Created: one year ago by: Guest

Jump to the latest result

Array.prototype.concat

Lodash concat

Array.prototype.push.apply()

spread operator

cached for + push

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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