Benchmark: native-slice-vs-chunk-real-map

HTML Preparation code:

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

Script Preparation code:

var rq = {
  files: Array.from({ length: 100000 }, () => Math.random()),
  foo: 'foo',
  bar: 'bar',
}

var chunk = function(arr, chunkSize) {
    const res = [];
    for (let i = 0; i < arr.length; i += chunkSize) {
        const chunk = arr.slice(i, i + chunkSize);
        res.push(chunk);
    }
    return res;
}

Tests:

Native slice
chunk(rq.files,5000).map(files => ({...rq, files}))
lodash chunk
_.chunk(rq.files,5000).map(files => ({...rq, files}))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Native slice
lodash chunk

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON benchmark definitions and explain what is being tested.

**Benchmark Overview**

The goal of this benchmark is to compare the performance of two approaches: native slicing and using the Lodash library for chunking.

**Native Slicing**

In the first test case, "Native slice", the script prepares an array `rq.files` with 100,000 random elements. Then, it defines a function `chunk` that takes an array and a chunk size as input. The function creates new arrays of fixed size (`chunkSize`) by slicing the original array at regular intervals.

The benchmark definition code is:
```
var chunk = function(arr, chunkSize) {
  const res = [];
  for (let i = 0; i < arr.length; i += chunkSize) {
    const chunk = arr.slice(i, i + chunkSize);
    res.push(chunk);
  }
  return res;
}
```
The test name suggests that this is the native implementation of chunking.

**Lodash Chunk**

In the second test case, "lodash chunk", the script prepares an array `rq.files` with 100,000 random elements. Then, it imports and uses the Lodash library (`_.chunk`) to chunk the array.

The benchmark definition code is:
```
_.chunk(rq.files,5000).map(files => ({...rq, files}))
```
This code uses the `_.chunk` function from Lodash to chunk the array into fixed-size chunks of size 5,000. The resulting chunks are then mapped over to create a new object with the original `rq` properties and the chunked `files`.

**Pros and Cons**

Here's a brief analysis of the pros and cons of each approach:

* **Native Slicing**:
	+ Pros: Native code is likely to be faster and more efficient since it doesn't involve an additional library.
	+ Cons: Requires manual implementation of the chunking logic, which can lead to errors or inconsistencies.
* **Lodash Chunk**:
	+ Pros: Easier to implement and maintain, as it leverages a well-tested and widely-used library. The Lodash `_.chunk` function is also optimized for performance.
	+ Cons: Adds an additional dependency (the Lodash library), which may impact execution time or memory usage.

**Lodash Library**

The Lodash library is a popular utility library that provides a wide range of functions for tasks such as array manipulation, string manipulation, and functional programming. In this benchmark, the `_.chunk` function is used to chunk the array into fixed-size chunks.

**Other Alternatives**

If you're interested in exploring alternative approaches, here are a few options:

* Using the built-in `Array.prototype.chunk()` method (introduced in ECMAScript 2019): This method creates an array of chunks from the original array.
* Implementing your own chunking algorithm using bitwise operations or other techniques.

However, these alternatives might not be as efficient or well-tested as the Lodash implementation, so it's recommended to stick with the established library for production code.

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/101.0.4951.64 Safari/537.36

Browser/OS: Chrome 101 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Native slice	12171.9 Ops/sec
lodash chunk	2834.2 Ops/sec

Related benchmarks:

native-slice-vs-chunk-real-map (version: 0)

Comparing performance of: Native slice vs lodash chunk

Created: 2 years ago by: Guest

Jump to the latest result

Native 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 one month ago):