Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
chunk perf
(version: 0)
Comparing performance of:
chunks_yield vs chunks_perf
Created:
2 years ago
by:
Guest
Go to the latest result
Tests:
chunks_yield
function chunks_yield(array, size) { function* chunk(arr, n) { for (let i = 0; i < arr.length; i += n) { yield arr.slice(i, i + n); } } return [...chunk(array, size)]; }
chunks_perf
function chunks(arr, n) { return arr.reduce((chunk, val) => { if (chunk[chunk.length - 1].length === n) chunk.push([]); chunk[chunk.length - 1].push(val); return chunk; }, [ [] ]); }
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (2)
Previous results
Fork
Test case name
Result
chunks_yield
chunks_perf
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/117.0.0.0 Safari/537.36
Browser/OS:
Chrome 117 on Mac OS X 10.15.7
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=503976" width="100%" height="500px"></iframe>
chunks_perf
1009.6M/s
chunks_yield
1004.8M/s
View exact numbers
Test name
Executions per second
✓
chunks_perf
1,009,620,288 Ops/sec
chunks_yield
1,004,751,744 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
Let's break down the provided benchmark and explain what's being tested, compared, and discussed. **Benchmark Overview** MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The benchmark in question consists of two test cases: `chunks_yield` and `chunks_perf`. These test cases are designed to measure the performance of two different approaches for chunking an array of elements into smaller, fixed-size chunks. **Chunking Approaches** There are two main approaches being compared: 1. **Yielding Chunks**: This approach uses a generator function (`chunks_yield`) that yields individual chunks of the array at a time. The idea is to generate each chunk on demand, allowing for more efficient use of resources and potentially better performance. 2. **Batching Chunks**: This approach uses an iterative algorithm (`chunks_perf`) that batches elements into chunks of a fixed size. The idea is to process all elements in batches, which can lead to cache-friendlier access patterns. **Comparison** The two approaches have different pros and cons: * **Yielding Chunks**: + Pros: Generates individual chunks on demand, potentially reduces memory allocation overhead. + Cons: May result in slower performance due to the overhead of generating each chunk individually. * **Batching Chunks**: + Pros: Can lead to better cache locality and potentially faster performance due to batch processing. + Cons: May require more memory upfront to store the batches, and may be less efficient for very large arrays. **Library Used** There is no explicit library mentioned in the benchmark definition or test cases. However, it's likely that these functions are part of a standard JavaScript implementation or a custom implementation. **JavaScript Features/Syntax** The `yield` keyword is used in both test cases to indicate that the function is a generator. This feature allows the function to produce a series of values over time, rather than computing them all at once and returning them in an array. **Other Alternatives** There are other approaches to chunking arrays that could be compared in a benchmark, such as: * Using `Array.prototype.slice()` with a step size * Using `Array.prototype.reduce()` without the chunking approach * Using a third-party library for array chunking (if one was used) However, these alternatives would likely require additional modifications to the test cases and benchmark setup. Overall, this benchmark provides a useful comparison of two different approaches to chunking arrays in JavaScript. By understanding the pros and cons of each approach, developers can make informed decisions about which method is best suited for their specific use case.
Related benchmarks
Set union
Unique Array: Lodash vs spread new Set vs reduce vs for v2
Slice vs For - 100 item
Comments
Confirm delete:
Do you really want to delete benchmark?