Benchmark: JS chunk huge array

Script Preparation code:

function arr() {
  return Array.from({ length: 100000 }, (_, idx) => `${++idx}`);
}

function chunk1(xs, n) {
  return xs.reduce(function (o, x, i) {
    const chunkIndex = Math.floor(i / n);
    if (!o[chunkIndex]) {
      o[chunkIndex] = [];
    }
    o[chunkIndex].push(x);
    return o;
  }, []);
}

function chunk2(xs, n) {
  return (xs.length <= n) ? [xs] : [
    xs.slice(0, n),
    ...chunk2(xs.slice(n), n)
  ]
}

function chunk3(array, size) {
  //declaring variable 'chunked' as an empty array
  let chunked = []

  //looping through the array until it has been entirely "manipulated" or split into our subarrays
  while (array.length > 0) {
    //taking the spliced segments completely out of our original array
    //pushing these subarrays into our new "chunked" array
    chunked.push(array.splice(0, size))
  }
  //returning the new array of subarrays
  return chunked
}

function chunk4(array, size) {
  //declaring variable 'chunked' as an empty array
  let chunked = []

  //setting our start point for our while loop at index 0
  let i = 0;
  //looping through the array until we have reached the final index
  while (i < array.length) {
    //push the sliced subarray of length 'size' into our new 'chunked' array
    chunked.push(array.slice(i, i + size))
    //increment by the size as to avoid duplicates
    i += size;
  }
  //return the array of subarrays
  return chunked
}

function chunk5(array, size) {
  //declaring variable 'chunked' as an empty array
  let chunked = [];

  //for loop iterating through every element of our input array
  for (let ele of array) {
    //declaring variable 'last' as the last index of our 'chunked' array
    const last = chunked[chunked.length - 1];

    //checking if last is undefined or if the last subarray is equal to the size
    if (!last || last.length === size) {
      //then we push the element to be a new subarray in 'chunked'
      chunked.push([ele])
    } else {
      //if not, then we add the element to the 'last' subarray
      last.push(ele)
    }
  }
  //return the array of subarrays
  return chunked
}

function chunk6(array, size) {
  const chunked_arr = [];
  for (let i = 0; i < array.length; i++) {
    const last = chunked_arr[chunked_arr.length - 1];
    if (!last || last.length === size) {
      chunked_arr.push([array[i]]);
    } else {
      last.push(array[i]);
    }
  }
  return chunked_arr;
}

function chunk7(array, size) {
  const chunked_arr = [];
  let copied = [...array]; // ES6 destructuring
  const numOfChild = Math.ceil(copied.length / size); // Round up to the nearest integer
  for (let i = 0; i < numOfChild; i++) {
    chunked_arr.push(copied.splice(0, size));
  }
  return chunked_arr;
}

function chunk8(array, size) {
  const chunked_arr = [];
  let index = 0;
  while (index < array.length) {
    chunked_arr.push(array.slice(index, size + index));
    index += size;
  }
  return chunked_arr;
}

function chunk9(array, size) {
  if (!array) return [];
  const firstChunk = array.slice(0, size); // create the first chunk of the given array
  if (!firstChunk.length) {
    return array; // this is the base case to terminal the recursive
  }
  return [firstChunk].concat(chunk9(array.slice(size, array.length), size));
}

function chunk10(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
}

Tests:

1
chunk1(arr(), 1000);
2
chunk2(arr(), 1000);
3
chunk3(arr(), 1000);
4
chunk4(arr(), 1000);
5
chunk5(arr(), 1000);
6
chunk6(arr(), 1000);
7
chunk7(arr(), 1000);
8
chunk8(arr(), 1000);
9
chunk9(arr(), 1000);
10
chunk10(arr(), 1000);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
1
2
3
4
5
6
7
8
9
10

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Firefox 102 on Windows

View result in a separate tab

Test name	Executions per second
1	75.2 Ops/sec
2	23.2 Ops/sec
3	168.9 Ops/sec
4	91.2 Ops/sec
5	69.9 Ops/sec
6	71.3 Ops/sec
7	72.3 Ops/sec
8	85.8 Ops/sec
9	23.5 Ops/sec
10	76.9 Ops/sec

Related benchmarks:

JS chunk huge array (version: 0)

Comparing performance of: 1 vs 2 vs 3 vs 4 vs 5 vs 6 vs 7 vs 8 vs 9 vs 10

Created: one year ago by: Guest

Jump to the latest result

1

2

3

4

5

6

7

8

9

10

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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