PHP function introduction—array_chunk(): split the array into small arrays of specified size

PHP function introduction—array_chunk(): Split the array into small arrays of specified size

In PHP development, processing arrays is a common task. Sometimes we need to split a large array into several small arrays of specified sizes. This is the scenario where the array_chunk() function appears. This article will introduce the usage of array_chunk() function in detail and provide some code examples.

The syntax of the array_chunk() function is as follows:
array array_chunk ( array $array , int $size [, bool $preserve_keys = false ] )

This function accepts three parameters: $ The array parameter is the array to be split, the $size parameter specifies the size of each small array, and the $preserve_keys parameter determines whether the split small array retains the key name of the original array.

The following is a simple example to split an array into small arrays of size 3:

<?php
$array = array('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j');
$chunks = array_chunk($array, 3);
print_r($chunks);
?>

In the above code, the original array $array contains 10 elements. We call the array_chunk() function, passing in $array and 3 as parameters. The result is that the original array is divided into 4 small arrays of size 3. Executing the above code, the output result is as follows:

Array
(
    [0] => Array
        (
            [0] => a
            [1] => b
            [2] => c
        )

    [1] => Array
        (
            [0] => d
            [1] => e
            [2] => f
        )

    [2] => Array
        (
            [0] => g
            [1] => h
            [2] => i
        )

    [3] => Array
        (
            [0] => j
        )

)

It can be seen that the original array was successfully divided into 4 small arrays, the size of each small array is 3, and the last small array has only one element.

In addition to the split small array not retaining the key names of the original array by default, we can also retain the key names of the original array by setting the third parameter $preserve_keys to true. The following is an example:

<?php
$array = array('a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5, 'f' => 6);
$chunks = array_chunk($array, 2, true);
print_r($chunks);
?>

In the above code, we map the elements of the original array $array to a key name. Call the array_chunk() function and pass in the parameters $array, 2, and true. The result is that the original array is divided into three small arrays, and the key names of the original array are retained. Executing the above code, the output result is as follows:

Array
(
    [0] => Array
        (
            [a] => 1
            [b] => 2
        )

    [1] => Array
        (
            [c] => 3
            [d] => 4
        )

    [2] => Array
        (
            [e] => 5
            [f] => 6
        )

)

It can be seen that the original array is successfully divided into 3 small arrays, and each small array retains the key name of the original array.

Summary:
The array_chunk() function is a very practical PHP array processing function. It can split a large array into multiple small arrays, and you can choose whether to retain the key names of the original array. In actual development, it can help us process large array data more conveniently. I hope the introduction and examples in this article can help readers better understand and use the array_chunk() function.

The above is the detailed content of PHP function introduction—array_chunk(): split the array into small arrays of specified size. For more information, please follow other related articles on the PHP Chinese website!