Benchmark: Chunk slice vs. Lodash 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: 1000000
}, () => Math.random())

function chunkSlice(raw, chunkSize) {
  const groups = [];
  let i = 0;
  while (i < raw.length) {
    groups.push(raw.slice(i, (i += chunkSize)));
  }
  return groups;
}

Tests:

Chunk by slice
chunkSlice(0,500)
lodash chunk
_.chunk(test,500)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Chunk by slice
lodash chunk

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Definition**

The benchmark definition is provided in JSON format, which includes:

1. **Script Preparation Code**: This code sets up a test array with 1 million random elements and defines two functions: `chunkSlice` and `_`. The latter is from the Lodash library.
2. **Html Preparation Code**: This code loads the Lodash JavaScript file from a CDN.

**Options Compared**

The benchmark compares two approaches for chunking an array:

1. **Chunk by Slice (Custom)**: Implemented in the `chunkSlice` function, which uses a while loop to split the array into chunks of 500 elements each.
2. **Lodash Chunk**: Implemented using the `_` function from Lodash, which provides a `chunk` method for splitting arrays.

**Pros and Cons**

### Chunk by Slice (Custom)

Pros:

* Flexibility: Allows the user to experiment with different chunk sizes.
* Control: Provides direct control over the chunking process.
* No external dependencies: Only relies on standard JavaScript features.

Cons:

* Potential performance overhead due to manual iteration.
* May not be optimized for performance compared to specialized libraries like Lodash.

### Lodash Chunk

Pros:

* Optimized performance: The `chunk` method is likely implemented in C++ and uses efficient algorithms.
* Reduced boilerplate code: Eliminates the need to write custom chunking logic.
* Robust error handling: Handles edge cases, such as arrays with an odd length.

Cons:

* External dependency: Requires Lodash to be included in the test environment.
* Less control: Relies on the implementation details of the `chunk` method.

**Lodash Library**

The `_` function is a utility function from the Lodash library. It provides various methods for working with arrays, objects, and functions. In this case, the `chunk` method splits an array into chunks of a specified size.

**Special JS Features or Syntax**

There are no special JavaScript features or syntax used in this benchmark. The code only relies on standard JavaScript features and the Lodash library's `chunk` method.

**Other Alternatives**

If you're interested in exploring other alternatives for chunking arrays, here are a few options:

1. **Array.prototype.slice()**: Can be used to split an array into chunks using `slice()` with an offset.
2. **Array.prototype.subarray()**: Similar to `slice()`, but allows specifying the start and end indices of each chunk.
3. **Underscore.js methods**: The Underscore library provides various utility functions, including `chunk()`, which can be used as an alternative to Lodash's `chunk` method.

Keep in mind that these alternatives may not offer the same performance benefits as optimized libraries like Lodash or the built-in `Array.prototype.slice()` method.

Latest run results:

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

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

Browser/OS: Chrome 127 on Windows

View result in a separate tab

Test name	Executions per second
Chunk by slice	15185287.0 Ops/sec
lodash chunk	157.2 Ops/sec

Related benchmarks:

Chunk slice vs. Lodash chunk (version: 1)

Comparing performance of: Chunk by slice vs lodash chunk

Created: 3 months ago by: Registered User

Jump to the latest result

Chunk by slice

lodash chunk

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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