Delicious Bookmark this on Delicious Share on Facebook SlashdotSlashdot It! Digg! Digg



PHP : Function Reference : Array Functions : array_chunk

array_chunk

Split an array into chunks (PHP 4 >= 4.2.0, PHP 5)
array array_chunk ( array input, int size [, bool preserve_keys] )

Chunks an array into size large chunks. The last chunk may contain less than size elements.

Parameters

input

The array to work on

size

The size of each chunk

preserve_keys

When set to TRUE keys will be preserved. Default is FALSE which will reindex the chunk numerically

Return Values

Returns a multidimensional numerically indexed array, starting with zero, with each dimension containing size elements.

Errors/Exceptions

If size is less than 1 E_WARNING will be thrown and NULL returned.

Examples

Example234.array_chunk() example

<?php
$input_array
= array('a', 'b', 'c', 'd', 'e');
print_r(array_chunk($input_array, 2));
print_r(array_chunk($input_array, 2, true));
?>

The above example will output:

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

[1] => Array
(
[0] => c
[1] => d
)

[2] => Array
(
[0] => e
)

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

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

[2] => Array
(
[4] => e
)

)


Related Examples ( Source code ) » array_chunk



Code Examples / Notes » array_chunk

mick

[Editors note: This function was based on a previous function by gphemsley at nospam users dot sourceforge.net]
For those of you that need array_chunk() for PHP < 4.2.0, this function should do the trick:
<?php
if (!function_exists('array_chunk')) {
function array_chunk( $input, $size, $preserve_keys = false) {
@reset( $input );

$i = $j = 0;
while( @list( $key, $value ) = @each( $input ) ) {
if( !( isset( $chunks[$i] ) ) ) {
  $chunks[$i] = array();
}
if( count( $chunks[$i] ) < $size ) {
if( $preserve_keys ) {
$chunks[$i][$key] = $value;
$j++;
} else {
$chunks[$i][] = $value;
}
} else {
$i++;
if( $preserve_keys ) {
$chunks[$i][$key] = $value;
$j++;
} else {
$j = 0;
$chunks[$i][$j] = $value;
}
}
}
return $chunks;
}
}
?>


azspot

Tried to use an example below (#56022) for array_chunk_fixed that would "partition" or divide an array into a desired number of split lists -- a useful procedure for "chunking" up objects or text items into columns, or partitioning any type of data resource. However, there seems to be a flaw with array_chunk_fixed — for instance, try it with a nine item list and with four partitions. It results in 3 entries with 3 items, then a blank array.
So, here is the output of my own dabbling on the matter:
<?php
function partition( $list, $p ) {
   $listlen = count( $list );
   $partlen = floor( $listlen / $p );
   $partrem = $listlen % $p;
   $partition = array();
   $mark = 0;
   for ($px = 0; $px < $p; $px++) {
       $incr = ($px < $partrem) ? $partlen + 1 : $partlen;
       $partition[$px] = array_slice( $list, $mark, $incr );
       $mark += $incr;
   }
   return $partition;
}
$citylist = array( "Black Canyon City", "Chandler", "Flagstaff", "Gilbert", "Glendale", "Globe", "Mesa", "Miami",
                  "Phoenix", "Peoria", "Prescott", "Scottsdale", "Sun City", "Surprise", "Tempe", "Tucson", "Wickenburg" );
print_r( partition( $citylist, 3 ) );
?>
Array
(
   [0] => Array
       (
           [0] => Black Canyon City
           [1] => Chandler
           [2] => Flagstaff
           [3] => Gilbert
           [4] => Glendale
           [5] => Globe
       )
   [1] => Array
       (
           [0] => Mesa
           [1] => Miami
           [2] => Phoenix
           [3] => Peoria
           [4] => Prescott
           [5] => Scottsdale
       )
   [2] => Array
       (
           [0] => Sun City
           [1] => Surprise
           [2] => Tempe
           [3] => Tucson
           [4] => Wickenburg
       )
)


magick dit crow ot gmail dit com

This function takes each few elements of an array and averages them together. It then places the averages in a new array. It is used to smooth out data. For example lets say you have a years worth of hit data to a site and you want to graph it by the week. Then use a bucket of 7 and graph the functions output.
function array_bucket($array, $bucket_size)  // bucket filter
{
if (!is_array($array)) return false; // no empty arrays
$buckets=array_chunk($array,$bucket_size);  // chop up array into bucket size units
foreach ($buckets as $bucket) $new_array[key($buckets])=array_sum($bucket)/count($bucket);
return $new_array;  // return new smooth array
}


berndt

SplitAssoziativArray() without array_chunk()
http://www.michael-berndt.de/ie/tux/assoziativen_array_zerteilen.htm


magick dit crow ot gmail dit com

Mistake key did not do what I thought. A patch.
function array_bucket($array,$bucket_size)// bucket filter
{
if (!is_array($array)) return false;
$buckets=array_chunk($array,$bucket_size);// chop up array into bucket size units
$I=0;
foreach ($buckets as $bucket)
{
$new_array[$I++]=array_sum($bucket)/count($bucket);
}
return $new_array;// return new array
}


22-mar-2006 12:19

Here my array_chunk_values( ) with values distributed by lines (columns are balanced as much as possible) :
<?php
   function array_chunk_vertical($data, $columns) {
       $n = count($data) ;
       $per_column = floor($n / $columns) ;
       $rest = $n % $columns ;
       // The map
       $per_columns = array( ) ;
       for ( $i = 0 ; $i < $columns ; $i++ ) {
           $per_columns[$i] = $per_column + ($i < $rest ? 1 : 0) ;
       }
       $tabular = array( ) ;
       foreach ( $per_columns as $rows ) {
           for ( $i = 0 ; $i < $rows ; $i++ ) {
               $tabular[$i][ ] = array_shift($data) ;
           }
       }
       return $tabular ;
   }
   header('Content-Type: text/plain') ;
   $data = array_chunk_vertical(range(1, 31), 7) ;
   foreach ( $data as $row ) {
       foreach ( $row as $value ) {
           printf('[%2s]', $value) ;
       }
       echo "\r\n" ;
   }
   /*
       Output :
       [ 1][ 6][11][16][20][24][28]
       [ 2][ 7][12][17][21][25][29]
       [ 3][ 8][13][18][22][26][30]
       [ 4][ 9][14][19][23][27][31]
       [ 5][10][15]
   */
?>


webmaster

based on the same syntax, useful about making columns :
<?php
function array_chunk_fixed($input, $num, $preserve_keys = FALSE) {
$count = count($input) ;
if($count)
$input = array_chunk($input, ceil($count/$num), $preserve_keys) ;
$input = array_pad($input, $num, array()) ;
return $input ;
}
$array = array(1, 2, 3, 4, 5) ;
print_r(array_chunk($array, 2)) ;
print_r(array_chunk_fixed($array, 2)) ;
?>
---- array_chunk : fixed number of sub-items ----
Array(
   [0] => Array(
           [0] => 1
           [1] => 2
       )
   [1] => Array(
           [0] => 3
           [1] => 4
       )
   [2] => Array(
           [0] => 5
       )
)
---- array_chunk : fixed number of columns ----
Array(
   [0] => Array(
           [0] => 1
           [1] => 2
           [2] => 3
       )
   [1] => Array(
           [0] => 4
           [1] => 5
       )
)


phpm

array_chunk() is helpful when constructing tables with a known number of columns but an unknown number of values, such as a calendar month. Example:
<?php
$values = range(1, 31);
$rows = array_chunk($values, 7);
print "<table>\n";
foreach ($rows as $row) {
print "<tr>\n";
foreach ($row as $value) {
print "<td>" . $value . "</td>\n";
}
print "</tr>\n";
}
print "</table>\n";
?>
Outputs:
1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31
The other direction is possible too, with the aid of a function included at the bottom of this note. Changing this line:
 $rows = array_chunk($values, 7);
To this:
 $rows = array_chunk_vertical($values, 7);
Produces a vertical calendar with seven columns:
1 6  11 16 21 26 31
2 7  12 17 22 27
3 8  13 18 23 28
4 9  14 19 24 29
5 10 15 20 25 30
You can also specify that $size refers to the number of rows, not columns:
 $rows = array_chunk_vertical($values, 7, false, false);
Producing this:
1 8  15 22 29
2 9  16 23 30
3 10 17 24 31
4 11 18 25
5 12 19 26
6 13 20 27
7 14 21 28
The function:
<?php
function array_chunk_vertical($input, $size, $preserve_keys = false, $size_is_horizontal = true)
{
$chunks = array();

if ($size_is_horizontal) {
$chunk_count = ceil(count($input) / $size);
} else {
$chunk_count = $size;
}

for ($chunk_index = 0; $chunk_index < $chunk_count; $chunk_index++) {
$chunks[] = array();
}
$chunk_index = 0;
foreach ($input as $key => $value)
{
if ($preserve_keys) {
$chunks[$chunk_index][$key] = $value;
} else {
$chunks[$chunk_index][] = $value;
}

if (++$chunk_index == $chunk_count) {
$chunk_index = 0;
}
}

return $chunks;
}
?>


cdblog

<?php
/**
* @return array
* @author Cocol
* @desc  use array_chunk with custom keys
* for more detail please visit http://php.clickz.cn/articles/array/array_chunk.html
*/
function array_chunk_custom($input_array = array(), $size = 0, $keys = array()) {
if (is_array($keys)) {
$values = array_values($input_array);
unset($input_array);
foreach ($keys as $key=>$val) {
$input_array[$val] = $values[$key];
}
}
$output_array = array_chunk($input_array,$size,1);
return $output_array;
}
$input_array = array('a', 'b', 'c', 'd', 'e','f','g','h');
$key_array = array('i','ii','iii','iv','v','vi','vii');
print_r(array_chunk_custom($input_array,2,$key_array));
?>
output:
Array
(
   [0] => Array
       (
           [i] => a
           [ii] => b
       )
   [1] => Array
       (
           [iii] => c
           [iv] => d
       )
   [2] => Array
       (
           [v] => e
           [vi] => f
       )
   [3] => Array
       (
           [vii] => g
       )
)


Change Language


Follow Navioo On Twitter
array_change_key_case
array_chunk
array_combine
array_count_values
array_diff_assoc
array_diff_key
array_diff_uassoc
array_diff_ukey
array_diff
array_fill_keys
array_fill
array_filter
array_flip
array_intersect_assoc
array_intersect_key
array_intersect_uassoc
array_intersect_ukey
array_intersect
array_key_exists
array_keys
array_map
array_merge_recursive
array_merge
array_multisort
array_pad
array_pop
array_product
array_push
array_rand
array_reduce
array_reverse
array_search
array_shift
array_slice
array_splice
array_sum
array_udiff_assoc
array_udiff_uassoc
array_udiff
array_uintersect_assoc
array_uintersect_uassoc
array_uintersect
array_unique
array_unshift
array_values
array_walk_recursive
array_walk
array
arsort
asort
compact
count
current
each
end
extract
in_array
key
krsort
ksort
list
natcasesort
natsort
next
pos
prev
range
reset
rsort
shuffle
sizeof
sort
uasort
uksort
usort
eXTReMe Tracker