English
English
How to avoid empty blocks when splitting arrays using array_chunk ?
In PHP programming, array_chunk() is a very practical function that is used to split a large array into multiple small arrays (blocks). This function has two parameters, the first is the original array, and the second is the size of each block. Although this function is very convenient, sometimes it produces blocks containing null values, which is not ideal for some application scenarios. So, how to avoid array_chunk() generating empty blocks when splitting arrays? Below we will discuss some common solutions.
First, let’s take a look at the basic usage of the array_chunk() function. Suppose we have a simple array and want to split it into chunks of size 3:
<?php
$arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
$result = array_chunk($arr, 3);
print_r($result);
?>
The output result is as follows:
Array
(
[0] => Array
(
[0] => 1
[1] => 2
[2] => 3
)
[1] => Array
(
[0] => 4
[1] => 5
[2] => 6
)
[2] => Array
(
[0] => 7
[1] => 8
[2] => 9
)
)
The above code successfully splits the original array into multiple blocks of size 3.
array_chunk() will split the array according to the specified block size. However, when the size of the array cannot be completely divisible by the block size, the last block may contain less than the specified number of elements, or even an empty block. If you want to avoid empty blocks, you can use the following methods to optimize.
To avoid empty blocks, we can use the array_filter() function to filter out any empty blocks after splitting the array. Here is an example of how to achieve this:
<?php
$arr = [1, 2, 3, 4, 5, 6, 7, 8];
$chunked = array_chunk($arr, 3);
// use array_filter() Filter out empty blocks
$chunked = array_filter($chunked, function($chunk) {
return !empty($chunk);
});
print_r($chunked);
?>
The output result is as follows:
Array
(
[0] => Array
(
[0] => 1
[1] => 2
[2] => 3
)
[1] => Array
(
[0] => 4
[1] => 5
[2] => 6
)
[2] => Array
(
[0] => 7
[1] => 8
)
)
By using array_filter() we can remove blocks containing empty elements so that no empty blocks appear.
If you don't want to filter empty blocks, consider adjusting the block size used when splitting the array. For example, you can dynamically calculate the appropriate block size based on the length of the array before splitting the array, ensuring that the last block is not empty. For example:
<?php
$arr = [1, 2, 3, 4, 5, 6, 7];
$chunkSize = 3;
$remaining = count($arr) % $chunkSize;
if ($remaining > 0) {
$chunkSize = $remaining;
}
$chunked = array_chunk($arr, $chunkSize);
print_r($chunked);
?>
In this way, the code will adjust the size of the last block according to the length of the array to avoid empty blocks.
Through the examples in this article, we understand the problem that the array_chunk() function may generate empty blocks when splitting an array, and explore two solutions: filtering empty blocks with array_filter() , or dynamically adjusting the block size to avoid the generation of empty blocks. Depending on different needs, you can choose the appropriate solution to ensure that the effect of the array is as expected.
