Benchmark: concat vs lodash.concat vs. push.apply vs.testsdf

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);
Array.prototype.push.apply()
Array.prototype.push.apply(arr1, arr2);
cached for + push
for (var i = 0, l = arr2.length; i < l; i++) { arr1.push(arr2[i]) }
naive
for (var i = 0, l = arr2.length; i < l; i++) { arr1[i] = arr2[i] }
naive imp
const arr1len = arr1.length; for (var i = 0, l = arr2.length; i < l; i++) { arr1[arr1len + i] = arr2[i] }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.prototype.concat
Array.prototype.push.apply()
cached for + push
naive
naive imp

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0.3 Safari/605.1.15

Browser/OS: Safari 14 on Mac OS X 10.15.6

View result in a separate tab

Test name	Executions per second
Array.prototype.concat	6551822.5 Ops/sec
Array.prototype.push.apply()	3447502.5 Ops/sec
cached for + push	1132438.1 Ops/sec
naive	1193868.4 Ops/sec
naive imp	829212.4 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its test cases.

**Benchmark Overview**

The benchmark is comparing the performance of different approaches to concatenate two arrays in JavaScript: `Array.prototype.concat()`, `Array.prototype.push.apply()`, and two naive approaches (`cached for + push` and `naive imp`).

**Options Compared**

1. **Array.prototype.concat()**: This method creates a new array by copying all elements from the original array, followed by the elements of the second array.
2. **Array.prototype.push.apply()**: This method appends all elements of the second array to the end of the first array.
3. **Cached for + push**: This approach uses a cached result (the length of the first array) and then pushes each element of the second array onto the end of the first array.
4. **Naive**: This approach iterates over the second array and assigns each element to the corresponding index in the first array.

**Pros and Cons**

* **Array.prototype.concat()**:
	+ Pros: Easy to use, creates a new array with the concatenated elements.
	+ Cons: Creates a new array, which can be memory-intensive for large arrays.
* **Array.prototype.push.apply()**:
	+ Pros: Efficient in terms of memory usage, as it modifies the existing array.
	+ Cons: Can be slower than `concat()` due to the overhead of the `apply()` method.
* **Cached for + push**:
	+ Pros: Balances memory usage and performance by using a cached result and pushing elements onto the end of the array.
	+ Cons: May not be as efficient as `push.apply()` in all cases, as it involves an additional operation (creating a new array).
* **Naive**:
	+ Pros: Easy to understand, but can be slow due to the overhead of explicit indexing and assignment.

**Library**

The benchmark uses Lodash's `concat` function, which is used for testing `Array.prototype.concat()`. Lodash is a popular JavaScript library that provides a set of utility functions, including array manipulation methods like `concat`.

**Special JS Features or Syntax**

None mentioned in the provided information. However, it's worth noting that some browsers may have specific features or syntax enabled that could affect the benchmark results (e.g., Safari 14).

**Alternatives**

Other approaches to concatenate arrays include:

* Using the spread operator (`[...arr1, ...arr2]`)
* Creating a new array using the `Array.from()` method
* Using a loop with indexing and assignment, similar to the naive approach described in the benchmark

Keep in mind that the best approach will depend on specific use cases and requirements. In general, `concat()` is a good choice when you need to create a new array, while `push.apply()` is suitable for modifying an existing array.

Related benchmarks:

concat vs lodash.concat vs. push.apply vs.testsdf (version: 0)

Comparing performance of: Array.prototype.concat vs Array.prototype.push.apply() vs cached for + push vs naive vs naive imp

Created: 3 years ago by: Guest

Jump to the latest result

Array.prototype.concat

Array.prototype.push.apply()

cached for + push

naive

naive imp

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