Benchmark: Js array chunk 2

Script Preparation code:

function chunk1(array, size) {
  let chunked = [];

  for (let ele of array) {
    const last = chunked[chunked.length - 1];

    if (!last || last.length === size) {
      chunked.push([ele])
    } else {
      last.push(ele)
    }
  }
  
  return chunked
}

function chunk2(array, size) {
  let chunked = [];

  array.forEach(element => {
    const last = chunked[chunked.length - 1];
    if (!last || last.length === size) {
      chunked.push([element])
    } else {
      last.push(element)
    }
  });
  
  return chunked
}

function chunk3(arr, n) {
  let chunked = arr.reduce((chunk, val) => {

    if (chunk[chunk.length - 1].length === n)
      chunk.push([]);

    chunk[chunk.length - 1].push(val);

    return chunk;
  }, [
    []
  ]);

  return chunked
}

function chunk4 ([...arr], n) {
  return [...Array(Math.ceil(arr.length) / n)].map(_ => arr.splice(0, n));
}

function chunk5([...array], size) {
  let chunked = []

  while(array.length > 0) {
    chunked.push(array.splice(0, size))
  }
  
  return chunked
}

Tests:

1
chunk1([1, 2, 3, 4], 2);
2
chunk2([1, 2, 3, 4], 2);
3
chunk3([1, 2, 3, 4], 2);
4
chunk4([1, 2, 3, 4], 2);
5
chunk5([1, 2, 3, 4], 2);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
1
2
3
4
5

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks to compare the performance of different approaches to solving similar problems.

The provided benchmark definition json represents a set of functions designed to chunk an array into smaller subarrays of a specified size. The individual test cases specify which function to use for each test case, along with the input array and chunk size.

**Benchmark Functions**

There are five benchmark functions:

1. `chunk1(array, size)`: This function takes an array and a chunk size as input, and returns a new array where elements are grouped into subarrays of the specified size.
2. `chunk2(array, size)`: Similar to `chunk1`, but uses the `forEach` method instead of a traditional for loop.
3. `chunk3(arr, n)`: This function takes an array and a chunk size as input, and returns a new array where elements are grouped into subarrays of the specified size using the `reduce` method.
4. `chunk4([...arr], n)`: This function takes an array and a chunk size as input, and returns a new array where elements are grouped into subarrays of the specified size using array spreading and the `splice` method.
5. `chunk5([...array], size)`: Similar to `chunk4`, but uses a while loop instead.

**Comparison**

The main difference between these functions is the approach used to group the elements into subarrays:

* `chunk1` and `chunk2` use a traditional for loop, which can be slower than other approaches.
* `chunk3` uses the `reduce` method, which is often faster because it avoids the overhead of function calls and loop variables.
* `chunk4` and `chunk5` use array manipulation techniques, such as spreading and splicing, which can be efficient but may also introduce additional overhead.

**Pros and Cons**

Here are some pros and cons for each approach:

1. **Traditional for loop (chunk1, chunk2)**:
	* Pros: Simple to understand and implement.
	* Cons: Can be slower than other approaches due to the overhead of loop variables.
2. **Reduce method (chunk3)**:
	* Pros: Often faster because it avoids function calls and loop variables.
	* Cons: May require more memory because of the intermediate array created by reduce.
3. **Array manipulation techniques (chunk4, chunk5)**:
	* Pros: Can be efficient due to the use of optimized array methods.
	* Cons: May introduce additional overhead due to the complexity of the code.

**Library and Special JS Features**

There are no libraries used in these benchmark functions, as they are designed to demonstrate basic JavaScript concepts.

There are no special JS features used in these benchmark functions either. They only utilize standard JavaScript syntax.

**Alternatives**

If you want to compare the performance of these functions, MeasureThat.net provides a simple way to run multiple benchmarks and compare their results. You can also use other tools, such as Node.js's built-in timing functions or libraries like microbenchmark.js, to benchmark your code.

Note: It's worth noting that the Yandex Browser 19 data in the provided benchmark results may be skewed by the specific browser implementation and its caching behavior.

Latest run results:

Run details: (Test run date: 5 years ago)

User agent: Mozilla/5.0 (Linux; Android 8.1.0; Lenovo K33a42) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.103 YaBrowser/19.4.4.317.00 Mobile Safari/537.36

Browser/OS: Yandex Browser 19 on Android 8.1.0

View result in a separate tab

Test name	Executions per second
1	276977.7 Ops/sec
2	293500.7 Ops/sec
3	499695.0 Ops/sec
4	34439.4 Ops/sec
5	52298.7 Ops/sec

Related benchmarks:

Js array chunk 2 (version: 0)

Comparing performance of: 1 vs 2 vs 3 vs 4 vs 5

Created: 5 years ago by: Guest

Jump to the latest result

1

2

3

4

5

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