PHP 5.4.36 Released

array_chunk

(PHP 4 >= 4.2.0, PHP 5)

array_chunkSplittet ein Array in Teile auf

Beschreibung

array array_chunk ( array $input , int $size [, bool $preserve_keys = false ] )

array_chunk() teilt das Array in Stücke mit size Werten auf. Das letzte Stück kann weniger als size Werte enthalten.

Parameter-Liste

input

Das Eingabe-Array

size

Die Größe jedes Arrays

preserve_keys

Falls auf TRUE gesetzt, bleiben die Schlüssel erhalten. Der Standard ist FALSE, wodurch jedes Stück neue numerische Indizes erhält.

Rückgabewerte

Gibt ein mehrdimensionales Array zurück, das beginnend mit Null jeweils size Elemente enthält.

Fehler/Exceptions

Wenn size kleiner als 1 ist, wird E_WARNING geworfen und NULL zurückgegeben.

Beispiele

Beispiel #1 array_chunk()-Beispiel

<?php
$input_array 
= array('a''b''c''d''e');
print_r(array_chunk($input_array2));
print_r(array_chunk($input_array2true));
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

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
        )

)

add a note add a note

User Contributed Notes 13 notes

up
21
azspot at gmail dot com
7 years ago
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
        )

)
up
13
Anonymous
8 years ago
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]
    */
?>
up
7
nate at ruggfamily dot com
4 years ago
If you just want to grab one chunk from an array, you should use array_slice().
up
3
stratboy
1 year ago
Hi, I've made  a function to split an array into chunks based on columns wanted. For example:

<?php $a = array(1,2,3,4,5,6,7,8); ?>

goal (say, for 3 columns):

<?php
array(
   array(
1,2,3),
   array(
4,5,6),
   array(
7,8)
);
?>

<?php
function get_array_columns($array, $columns){
       
       
$columns_map = array();
        for(
$i=0; $i<$columns; $i++){ $columns_map[] = 0; }//init columns
       
        //create map
       
$count = count($array);
       
$position = 0;
        while(
$count > 0){
           
$columns_map[$position]++;
           
$position = ($position < $columns-1) ? ++$position : 0;
           
$count--;
        }

       
//chunk the array based on map
       
$chunked = array();
        foreach(
$columns_map as $map){
           
$chunked[] = array_splice($array,0,$map);
        }
       
        return
$chunked;
    }
//end get_array_columns
?>
up
3
magick dit crow ot gmail dit com
9 years ago
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
}
up
3
webmaster at cafe-clope dot net
9 years ago
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
        )
)
up
4
phpm at nreynolds dot me dot uk
10 years ago
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;
}

?>
up
3
OIS
6 years ago
Response to azspot at gmail dot com function partition.

$columns = 3;
$citylist = array('Black Canyon City', 'Chandler', 'Flagstaff', 'Gilbert', 'Glendale', 'Globe', 'Mesa', 'Miami', 'Phoenix', 'Peoria', 'Prescott', 'Scottsdale', 'Sun City', 'Surprise', 'Tempe', 'Tucson', 'Wickenburg');
print_r(array_chunk($citylist, ceil(count($citylist) / $columns)));

Output:
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
        )

)
up
2
dead dot screamer at seznam dot cz
5 years ago
This function can be used to reverse effect of <?php array_Chunk()?>.
<?php
function array_Unchunk($array)
{
    return
call_User_Func_Array('array_Merge',$array);
}

header('Content-Type: text/plain');
$array=array(
    array(
           
'Black Canyon City',
           
'Chandler',
           
'Flagstaff',
           
'Gilbert',
           
'Glendale',
           
'Globe',
    ),
    array(
           
'Mesa',
           
'Miami',
           
'Phoenix',
           
'Peoria',
           
'Prescott',
           
'Scottsdale',
    ),
    array(
           
'Sun City',
           
'Surprise',
           
'Tempe',
           
'Tucson',
           
'Wickenburg',
    ),
);
var_Dump(array_Unchunk($array));
?>

Output:
array(17) {
  [0]=>
  string(17) "Black Canyon City"
  [1]=>
  string(8) "Chandler"
  [2]=>
  string(9) "Flagstaff"
  [3]=>
  string(7) "Gilbert"
  [4]=>
  string(8) "Glendale"
  [5]=>
  string(5) "Globe"
  [6]=>
  string(4) "Mesa"
  [7]=>
  string(5) "Miami"
  [8]=>
  string(7) "Phoenix"
  [9]=>
  string(6) "Peoria"
  [10]=>
  string(8) "Prescott"
  [11]=>
  string(10) "Scottsdale"
  [12]=>
  string(8) "Sun City"
  [13]=>
  string(8) "Surprise"
  [14]=>
  string(5) "Tempe"
  [15]=>
  string(6) "Tucson"
  [16]=>
  string(10) "Wickenburg"
}
up
1
mick at vandermostvanspijk dot nl
10 years ago
[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;
    }
}
?>
up
1
Anonymous
7 months ago
Couldn't get the array_chunk_values() working, so ended up with this implementation:

<?php
function array_chunk_columns($data, $num_columns) {
 
$n = count($data);
 
$per_column = floor($n / $num_columns);
 
$rest = $n % $num_columns;

 
$columns = array();
 
$index = 0;
  for (
$i = 0; $i < $num_columns; $i++) {
   
// Add an extra item to each column while the column number is less than the
    // remainder.
   
$add_rest = ($rest && ($i < $rest)) ? 1 : 0;
   
$number = $per_column + $add_rest;
   
$columns[] = array_slice($data, $index, $number);
   
$index += $number;
  }

  return
$columns;
}

?>
up
0
magick dit crow ot gmail dit com
9 years ago
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
}
up
-2
Rasmus Schultz (http://mindplay.dk)
5 years ago
Unfortunately, this function only accepts real arrays, not iterable objects... For that, you need this function:

<?php

function break_array($array, $page_size) {
 
 
$arrays = array();
 
$i = 0;
 
  foreach (
$array as $index => $item) {
    if (
$i++ % $page_size == 0) {
     
$arrays[] = array();
     
$current = & $arrays[count($arrays)-1];
    }
   
$current[] = $item;
  }
 
  return
$arrays;
 
}

?>
To Top