Benchmark: Lodash Chunk vs Native Chunk

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

var test = Array.from({
    length: 100000
}, () => Math.random())

function chunk(array, size) {
  const result = [];
  for (let i = 0; i < array.length; i += size) {
    result.push(array.slice(i, i + size));
  }
  return result;
}

Tests:

Lodash Chunk
_.chunk(test,5000)
Native Chunk With Slice
chunk(test,5000)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash Chunk
Native Chunk With Slice

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36

Browser/OS: Chrome 118 on Windows

View result in a separate tab

Test name	Executions per second
Lodash Chunk	2464.3 Ops/sec
Native Chunk With Slice	9145.9 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 options.

**Benchmark Overview**

The benchmark is designed to compare the performance of two approaches for chunking an array: Lodash's `chunk` function and the native `slice` method.

**Chunking Approaches**

There are two main approaches being compared:

1. **Lodash Chunk**: The `chunk` function from Lodash is used to split the input array into chunks of a specified size (5000 in this case).
2. **Native Chunk with Slice**: This approach uses the native `slice` method to create chunks of the same size.

**Pros and Cons**

Here are some pros and cons of each approach:

* **Lodash Chunk**
	+ Pros:
		- More readable code, as it's a higher-level function that abstracts away the details of array manipulation.
		- Less error-prone, as Lodash handles edge cases and invalid input for you.
	- Cons:
		- Potential performance overhead due to the use of a library function.
		- May have slower execution speed compared to native methods.
* **Native Chunk with Slice**
	+ Pros:
		- Faster execution speed, as it's a native method that doesn't incur any overhead from a library function.
		- More control over the chunking process, as you can fine-tune the size and behavior of the chunks.
	- Cons:
		- More verbose code, as you need to manually implement the chunking logic using `slice`.
		- May require more expertise in JavaScript array manipulation.

**Library: Lodash**

Lodash is a popular JavaScript library that provides a collection of utility functions for tasks such as string manipulation, array transformation, and more. The `chunk` function is one of its many useful tools for working with arrays. In this benchmark, Lodash's `chunk` function is used to split the input array into chunks.

**Special JS Feature/ Syntax**

There isn't any special JavaScript feature or syntax being used in this benchmark that requires explanation.

**Alternatives**

If you're looking for alternative approaches to chunking an array, here are a few options:

* Using `Array.prototype.reduce` and creating chunks manually.
* Utilizing a library like **moment** (for date manipulation) or **underscore** (for other utility functions).
* Implementing custom array slicing and concatenation logic using loops.

However, for simple use cases, the native `slice` method is usually sufficient and efficient.

Related benchmarks:

Lodash Chunk vs Native Chunk (version: 0)

Comparing performance of: Native chunk using slice vs lodash chunk. Similar to https://www.measurethat.net/Benchmarks/Show/9855/0/native-slice-vs-chunk

Comparing performance of: Lodash Chunk vs Native Chunk With Slice

Created: one year ago by: Guest

Jump to the latest result

Lodash Chunk

Native Chunk With Slice

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