How to Split Array into Specific Number of Chunks in PHP ?

This article will show you how to split an array into a specific number of chunks using PHP. There are basically two approaches to solve this problem, these are:

Using array_chunk() function

The array_chunk() function is used to split an array into parts or chunks of a given size depending upon the parameters passed to the function. The last chunk may contain fewer elements than the desired size of the chunk.

Syntax:

array array_chunk( $array, $size, $preserve_keys )

Example:

<?php 

// PHP Program to Split Array into 
// Specific Number of Chunks 

// Declare an array 
$arr = [ 
    "G", "e", "e", "k", "s", 
    "f", "o", "r", "G", "e", 
    "e", "k", "s"
]; 

// Use array_chunk() function to 
// split array into chunks 
print_r(array_chunk($arr, 4)); 

?>

Output:

Array ( 
    [0] => Array ( 
        [0] => G 
        [1] => e 
        [2] => e 
        [3] => k 
    ) 
    [1] => Array ( 
        [0] => s 
        [1] => f 
        [2] => o 
        [3] => r 
    ) 
    [2] => Array ( 
        [0] => G 
        [1] => e 
        [2] => e 
        [3] => k 
    ) 
    [3] => Array ( 
        [0] => s 
    ) 
)

Using array_slice() function

The array_slice() function is used to fetch a part of an array by slicing through it, according to the users choice.

Syntax:

array_slice($array, $start_point, $slicing_range, preserve)

Example:

<?php 

// PHP Program to split array into 
// Specific Number of Chunks 

// Declare an array 
$arr = [ 
    "G", "e", "e", "k", "s", 
    "f", "o", "r", "G", "e", 
    "e", "k", "s"
]; 

// Use array_slice() function to 
// split array into chunks 
$splitArr = [ 
    array_slice($arr, 0, 4), 
    array_slice($arr, 4, 7), 
    array_slice($arr, 8, 12), 
    array_slice($arr, 12, 1), 
]; 

print_r($splitArr); 

?>

Output:

Array ( 
    [0] => Array ( 
        [0] => G 
        [1] => e 
        [2] => e 
        [3] => k 
    ) 
    [1] => Array ( 
        [0] => s 
        [1] => f 
        [2] => o 
        [3] => r 
    ) 
    [2] => Array ( 
        [0] => G 
        [1] => e 
        [2] => e 
        [3] => k 
    ) 
    [3] => Array ( 
        [0] => s 
    ) 
)

Approach 3: Using array_map with range

You can use array_map with range to generate chunk indexes based on the array size and chunk size. Then, apply array_slice to extract chunks using these indexes, resulting in the array split into specific-sized chunks.

Example: This PHP script defines a custom_array_chunk function to split an array $arr into chunks of size 4 using array_map, range, and array_slice, displaying the result with print_r.

<?php

// Custom function to split array into chunks
function custom_array_chunk($array, $chunk_size) {
    // Calculate the number of chunks needed
    $num_chunks = ceil(count($array) / $chunk_size);
    
    // Use array_map with range to create chunks
    return array_map(function($i) use ($array, $chunk_size) {
        // Calculate start index of current chunk
        $start = $i * $chunk_size;
        
        // Return slice of array for current chunk
        return array_slice($array, $start, $chunk_size);
    }, range(0, $num_chunks - 1));
}

// Declare an array
$arr = [ 
    "G", "e", "e", "k", "s", 
    "f", "o", "r", "G", "e", 
    "e", "k", "s"
]; 

// Split array into chunks of size 4 using custom function
$result = custom_array_chunk($arr, 4);

// Print the result
print_r($result);

?>

Array
(
    [0] => Array
        (
            [0] => G
            [1] => e
            [2] => e
            [3] => k
        )

    [1] => Array
        (
            [0] => s
            [1] => f
 ...

Using a Generator Function

In the generator function approach, define a generator that yields chunks of the original array. Calculate the chunk size based on the desired number of chunks, then use array_slice() within the generator. Convert the generator's output to an array using iterator_to_array().

Example:

<?php
function array_chunk_generator($array, $numberOfChunks) {
    $chunkSize = ceil(count($array) / $numberOfChunks);
    for ($i = 0; $i < $numberOfChunks; $i++) {
        yield array_slice($array, $i * $chunkSize, $chunkSize);
    }
}

$array = range(1, 10);
$numberOfChunks = 3;
$chunks = iterator_to_array(array_chunk_generator($array, $numberOfChunks));

print_r($chunks);
?>

Array
(
    [0] => Array
        (
            [0] => 1
            [1] => 2
            [2] => 3
            [3] => 4
        )

    [1] => Array
        (
            [0] => 5
            [1] => 6
 ...

Using a While Loop

This method involves calculating the chunk size based on the desired number of chunks and using a while loop to slice the array into these chunks.

Example: In this example, the splitArrayIntoChunks function first calculates the chunk size by dividing the total number of elements by the number of desired chunks and rounding up using ceil. It then initializes an empty array for the chunks and an index variable. The while loop iterates through the array, slicing off chunks of the calculated size and adding them to the chunks array until the entire array has been processed.

<?php
   function splitArrayIntoChunks($array, $numChunks) {
    $chunkSize = ceil(count($array) / $numChunks);
    $chunks = [];
    $index = 0;

    while ($index < count($array)) {
        $chunks[] = array_slice($array, $index, $chunkSize);
        $index += $chunkSize;
    }

    return $chunks;
}

// Example usage
$array = ['G', 'e', 'e', 'k', 's', 'f', 'o', 'r', 'G', 'e', 'e', 'k', 's'];
$numChunks = 4;

$chunks = splitArrayIntoChunks($array, $numChunks);
print_r($chunks);

?>

Array
(
    [0] => Array
        (
            [0] => G
            [1] => e
            [2] => e
            [3] => k
        )

    [1] => Array
        (
            [0] => s
            [1] => f
 ...

Using array_map with range

You can use array_map with range to generate chunk indexes based on the array size and chunk size. Then, apply array_slice to extract chunks using these indexes, resulting in the array split into specific-sized chunks.

Example:

<?php
   function custom_array_chunk($array, $size) {
    return array_map(function($i) use ($array, $size) {
        return array_slice($array, $i * $size, $size);
    }, range(0, ceil(count($array) / $size) - 1));
}

// Example usage:
$array = ['G', 'e', 'e', 'k', 's', 'f', 'o', 'r', 'G', 'e', 'e', 'k', 's'];
$chunked_array = custom_array_chunk($array, 4);
print_r($chunked_array);

?>

Array
(
    [0] => Array
        (
            [0] => G
            [1] => e
            [2] => e
            [3] => k
        )

    [1] => Array
        (
            [0] => s
            [1] => f
 ...