Benchmark: Array.prototype.push vs Array.prototype.push.apply

Script Preparation code:

var arr1 = Array(100).fill([{n: ''}]);
var arr2 = Array(100).fill([{n: ''}]);

Tests:

Array.prototype.push
arr1.push(arr2)
Array.prototype.push.apply
Array.prototype.push.apply(arr1, arr2)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.prototype.push
Array.prototype.push.apply

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Firefox 120 on Linux

View result in a separate tab

Test name	Executions per second
Array.prototype.push	19691586.0 Ops/sec
Array.prototype.push.apply	138120.9 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

The provided JSON represents a benchmark test case on MeasureThat.net, which compares two approaches for adding elements to an array using the `push` and `apply` methods.

**What is being tested?**

In this benchmark, we're testing the performance difference between two methods:

1. `Array.prototype.push(arr2)`: This method calls the `push` method on the `arr1` array, passing the entire `arr2` array as an argument.
2. `Array.prototype.push.apply(arr1, arr2)`: This method calls the `apply` method on the `push` method of the `arr1` array, passing both `arr1` and `arr2` as arguments.

**Options compared**

The two options being compared are:

* `push` (with a single argument)
* `push.apply` (with multiple arguments)

**Pros and Cons:**

**Push (with a single argument)**

Pros:

* Simpler and more concise code
* Easier to read and understand
* May be optimized by the engine for this specific use case

Cons:

* May incur additional overhead due to calling another method, which could be slower than passing arguments directly

**Push.apply (with multiple arguments)**

Pros:

* Can pass both arrays in a single operation, potentially reducing overhead
* May be optimized by the engine for this specific use case

Cons:

* More verbose and complex code
* May incur additional overhead due to calling another method, which could be slower than passing arguments directly

**Library usage**

Neither of these methods uses an external library. They are both part of the built-in JavaScript API.

**Special JS features or syntax**

There are no special JavaScript features or syntax used in this benchmark. The focus is solely on the performance difference between two specific method calls.

**Other alternatives**

If we were to consider alternative approaches for adding elements to an array, some options might include:

* Using `concat` instead of `push`: `arr1.concat(arr2)`
* Using a loop to iterate over the elements and add them individually
* Using a library like Lodash or Ramda, which provides optimized functions for working with arrays

However, these alternatives are not part of the benchmark being tested on MeasureThat.net.

I hope this explanation helps! Let me know if you have any further questions.

Related benchmarks:

Array.prototype.push vs Array.prototype.push.apply (version: 0)

Comparing performance of: Array.prototype.push vs Array.prototype.push.apply

Created: 4 years ago by: Guest

Jump to the latest result

Array.prototype.push

Array.prototype.push.apply

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