Benchmark: Chunk array generator(slice) vs slice vs for loop

Script Preparation code:

var data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];

Tests:

slice
let chunksize = 10; let pos = 0; let chunk = []; while (pos <= data.length) { chunk = data.slice(pos, pos + chunksize); console.log(chunk); pos = pos + chunksize; }
push
let chunksize = 10; let pos = 0; let chunk = []; for (let pos = 0; pos <= data.length; pos++) { chunk.push(data[pos]); if (pos % chunksize === 0 || pos === data.length) { console.log(chunk); chunk = []; } }
generator (slice)
function* getBatch(records, currentPos = 0, chunksize = 10) { let pos = 0; while (pos <= records.length) { yield records.slice(pos, pos + chunksize); pos = pos + chunksize; } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
slice
push
generator (slice)

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:146.0) Gecko/20100101 Firefox/146.0

Browser/OS: Firefox 146 on Windows

View result in a separate tab

Test name	Executions per second
slice	22658.2 Ops/sec
push	22290.8 Ops/sec
generator (slice)	757923264.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of what is being tested on the provided JSON.

The benchmark is testing three different approaches to generate chunks from an array:

1. **slice**: This approach uses the `Array.prototype.slice()` method to extract a portion of the array and return it as a new array. The slice starts at the current position (`pos`) and spans `chunksize` elements.
2. **push**: This approach uses a simple loop to push each element from the array into a new array, which is then cleared and logged when the chunk size is reached or the end of the array is reached.
3. **generator (slice)**: This approach uses a generator function (`getBatch`) to yield chunks of the array. The generator function takes three parameters: `records` (the original array), `currentPos` (the current position in the array), and `chunksize`. It uses a loop to extract chunks from the array using `Array.prototype.slice()` and yields each chunk.

**Pros and Cons of each approach:**

* **slice**: This approach is concise and efficient, as it leverages the optimized implementation of `Array.prototype.slice()`. However, it can be less intuitive for developers who are not familiar with this method.
* **push**: This approach is more explicit and easy to understand, but it can be slower and less memory-efficient than the slice approach. The loop and push operations can introduce additional overhead.
* **generator (slice)**: This approach provides a good balance between efficiency and readability. It uses a generator function, which can be beneficial for developers familiar with this concept. However, it may require more setup and understanding of the underlying mechanics.

**Library usage:**

The benchmark does not use any external libraries beyond the standard JavaScript features.

**Special JS feature or syntax:**

None of the approaches rely on special JavaScript features or syntax beyond what is commonly used in modern JavaScript development (e.g., `let`, `const`, arrow functions, etc.).

**Alternatives:**

Other alternatives to these approaches could include:

* Using a library like `lodash.chunk` or `rxjs/operators.chunkSize` for chunking and iteration.
* Implementing custom chunking logic using loops and conditional statements.
* Using a more functional programming approach with mapReduce or reduce-like functions.

Keep in mind that the choice of approach depends on the specific use case, performance requirements, and personal preference.

Related benchmarks:

Chunk array generator(slice) vs slice vs for loop (version: 0)

Comparing performance of: slice vs push vs generator (slice)

Created: 3 years ago by: Guest

Jump to the latest result

slice

push

generator (slice)

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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