Benchmark: Lodash isEqual test3123

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.4/lodash.min.js"></script>

Script Preparation code:

var arr = Array.from({length: 100000}, () => Math.floor(Math.random() * 40));;
var arr2 = Array.from({length: 100000}, () => Math.floor(Math.random() * 40));;
window.arr = arr;
window.arr2= arr2;

Tests:

_.concat
_.concat(window.arr,window.arr2);
concat
window.arr.concat(window.arr2)
12
[...window.arr, ...window.arr2]

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
_.concat
concat
12

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36

Browser/OS: Chrome 120 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
_.concat	891.0 Ops/sec
concat	7703.0 Ops/sec
12	2528.9 Ops/sec

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

LLMs can make mistakes. Check important info.

**What is tested?**

MeasureThat.net tests the performance of different approaches to concatenate arrays in JavaScript. The benchmark definition json contains three test cases:

1. `_.concat(window.arr,window.arr2)` - This test case uses the Lodash library's `concat` function to concatenate two arrays.
2. `window.arr.concat(window.arr2)` - This test case uses the built-in `concat` method of JavaScript arrays.
3. `[...window.arr, ...window.arr2]` - This test case uses the spread operator (`...`) to concatenate two arrays.

The benchmark aims to determine which approach is the most efficient in terms of execution time per second.

**Options compared**

The three options compared are:

1. Lodash's `concat` function
2. Built-in JavaScript array `concat` method
3. Spread operator (`...`) for array concatenation

**Pros and Cons of each approach:**

1. **Lodash's `concat` function**
	* Pros:
		+ Convenient and consistent API across various programming languages.
		+ May be faster than built-in methods due to optimized implementation.
	* Cons:
		+ Requires including an additional library, which may add overhead.
		+ May not be compatible with all browsers or environments.
2. **Built-in JavaScript array `concat` method**
	* Pros:
		+ Lightweight and widely supported across most browsers and environments.
		+ No additional libraries required.
	* Cons:
		+ API can be less consistent and predictable compared to Lodash's `concat`.
		+ May not be as optimized or fast as Lodash's implementation.
3. **Spread operator (`...`) for array concatenation**
	* Pros:
		+ Simple and concise syntax, easy to read and write.
		+ Lightweight and widely supported across most browsers and environments.
	* Cons:
		+ Limited compatibility with older browsers or environments that do not support the spread operator.
		+ May not be as performant as Lodash's `concat` function due to additional overhead.

**Library: Lodash**

Lodash is a popular JavaScript utility library that provides a comprehensive set of functions for various tasks, including array manipulation. In this benchmark, Lodash's `concat` function is used to concatenate two arrays. The inclusion of Lodash adds an additional layer of complexity and potential performance impact compared to using only built-in methods.

**Special JS feature: Spread operator (`...`)**

The spread operator was introduced in ECMAScript 2015 (ES6) as a new way to create new arrays from existing ones by spreading elements into a new array. This feature allows for concise and expressive code, but may not be supported in older browsers or environments.

**Other alternatives**

For array concatenation, other approaches include:

1. Using `Array.prototype.push()` with two separate calls.
2. Using `Array.prototype.splice()` to insert one of the arrays into another.
3. Using `Array.prototype.slice()` followed by an assignment using `Array.prototype.concat()` (although this approach may be less efficient due to additional overhead).

It's worth noting that, in general, the choice of approach for array concatenation depends on specific use cases and performance requirements.

Related benchmarks:

Lodash isEqual test3123 (version: 0)

Test on isEqual performance2

Comparing performance of: _.concat vs concat vs 12

Created: 2 years ago by: Guest

Jump to the latest result

_.concat

concat

12

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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