Benchmark: best concat - MeasureThat.net

HTML Preparation code:

<script>
  const arr1 = ['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten']
  const arr2 = ['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten']
</script>

Tests:

regular concat
arr1.concat(arr2)
prototype
Array.prototype.concat(arr1, arr2)
prototype apply
Array.prototype.concat.apply(arr1, arr2)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
regular concat
prototype
prototype apply

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.114 Safari/537.36

Browser/OS: Chrome 89 on Linux

View result in a separate tab

Test name	Executions per second
regular concat	1683121.9 Ops/sec
prototype	645864.5 Ops/sec
prototype apply	501381.9 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark information to explain what's being tested, compare different approaches, and discuss pros and cons of each.

**Benchmark Definition JSON**

The provided `benchmark definition` json contains three benchmark definitions:

1. `"arr1.concat(arr2)"`: This is a simple function call that concatenates two arrays using the `concat()` method.
2. `"Array.prototype.concat(arr1, arr2)"`: This uses the `concat()` method directly on the `Array.prototype`. The first argument is an array (`arr1`), and the second argument is another array (`arr2`).
3. `"Array.prototype.concat.apply(arr1, arr2)"`: This uses the `apply()` method to invoke `concat()` on the `Array.prototype`, passing both `arr1` and `arr2` as arguments.

**Options Compared**

These three approaches compare different ways of calling the `concat()` method:

* **Method 1: Direct Function Call (`arr1.concat(arr2)`)**: This approach calls the `concat()` method directly on an array, using the dot notation.
* **Method 2: Prototype Method Call (`Array.prototype.concat(arr1, arr2)`)**: This approach calls a method on the global `Array.prototype` object.
* **Method 3: Apply Method Call (`Array.prototype.concat.apply(arr1, arr2)`)**: This approach uses the `apply()` method to invoke `concat()` on the `Array.prototype`, passing both `arr1` and `arr2` as arguments.

**Pros and Cons**

Here's a brief summary of each approach:

* **Method 1 (Direct Function Call):**
	+ Pros: Simple, straightforward.
	+ Cons: May be slower due to method lookup, which can lead to cache misses in modern JavaScript engines.
* **Method 2 (Prototype Method Call):**
	+ Pros: Can be faster since the method call is a constant-time operation on the global `Array.prototype`.
	+ Cons: May require additional overhead for method lookups and checks.
* **Method 3 (Apply Method Call):**
	+ Pros: Similar to Method 2, but uses `apply()` to invoke `concat()`, which can be optimized by the JavaScript engine.
	+ Cons: Requires using `apply()`, which may add unnecessary complexity.

**Library/Prototype**

In all three cases, the `Array` prototype is used. The `Array.prototype` is a built-in object in JavaScript that provides various methods for array manipulation, including `concat()`.

**Special JS Feature/Syntax**

None of the benchmark definitions use any special JavaScript features or syntax beyond standard language constructs.

**Other Alternatives**

If you wanted to explore other alternatives, here are some possible options:

* Using `Array.prototype.push.apply(arr1, arr2)` instead of `concat()`.
* Implementing a custom concatenation function using `for` loops or recursion.
* Using a different library or framework that provides optimized concatenation functions.

Keep in mind that the performance differences between these approaches may be negligible for most use cases. However, if you're optimizing critical code paths, understanding the underlying mechanics and potential performance implications can help guide your optimization efforts.

Related benchmarks:

best concat (version: 0)

Comparing performance of: regular concat vs prototype vs prototype apply

Created: 3 years ago by: Guest

Jump to the latest result

regular concat

prototype

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