Benchmark: JS arrays.. - MeasureThat.net

Script Preparation code:

var toAppend = Array(1).fill("jhd");
var original = [ "first", "second", "third" ];

Tests:

Concat
var res = original.concat(toAppend);
Push
var res = original.push(...toAppend);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Concat
Push

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gemma2:9b, generated one month ago):

LLMs can make mistakes. Check important info.

This benchmark tests two different methods for appending elements to an existing JavaScript array: `concat` and `push`.

Let's break down each method and their pros/cons:

**1. `concat()`**

* **Benchmark Definition:** `var res = original.concat(toAppend);`
*  This method creates a *new* array containing all the elements from the original array (`original`) followed by the elements from the `toAppend` array.

* **Pros:** 
      * Doesn't modify the original array, preserving its original state. This can be crucial if you need to keep multiple copies of your data.
      * Returns a new array, allowing you to directly use the result without re-assigning it.

* **Cons:**
      * Can be less performant than `push` for appending only one or two elements because it creates a completely new array.

**2. `push()`**

* **Benchmark Definition:** `var res = original.push(...toAppend);`
* This method modifies the original array (`original`) by adding all the elements from `toAppend` to its end. It then returns the *modified* length of the array.

* **Pros:** 
      *  In-place modification can be more memory-efficient, especially when dealing with large arrays.
      * Generally faster than `concat()` when appending multiple elements.

* **Cons:**
      * Modifies the original array directly, which might not be desirable if you need to keep multiple versions of your data unchanged.

**Other Considerations:**

* **Context Matters:** The best approach depends heavily on your use case. If you frequently append small sets of elements and need to preserve the original array, `concat()` is a good option. For larger sets or when in-place modification is acceptable, `push()` might be more efficient.
* **Libraries:** This benchmark doesn't involve any external libraries.

**Alternatives:**

* **`Array.prototype.splice(endIndex, deleteCount, item1, ..., itemN)`:**  More versatile than `concat` and `push`, allowing you to insert elements at specific positions within an array, remove existing elements, and modify the array's content in more complex ways.

Let me know if you have any other questions or want to explore specific scenarios in more detail!

Latest run results:

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

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

Browser/OS: Safari 13 on Mac OS X 10.14.6

View result in a separate tab

Test name	Executions per second
Concat	4918863.0 Ops/sec
Push	4168731.5 Ops/sec

Related benchmarks:

JS arrays.. (version: 1)

Comparing performance of: Concat vs Push

Created: 4 years ago by: Registered User

Jump to the latest result

Concat

Push

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gemma2:9b, generated one month ago):