我有一个包含18个值的数组：
$array = array('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r');
我想将这个数组拆分成12个不同的数组，所以看起来应该是这样的：
array(
0 => array('a', 'b'),
1 => array('c', 'd'),
2 => array('e', 'f'),
3 => array('g', 'h'),
4 => array('i', 'j'),
5 => array('k', 'l'),
6 => array('m'),
7 => array('n'),
8 => array('o'),
9 => array('p'),
10 => array('q'),
11 => array('r')
)
我的功能似乎不起作用
function array_split($array, $parts){
return array_chunk($array, ceil(count($array) / $parts));
}
$result = array_split($array, 12);
因为我得到9个不同的数组而不是12个。它会返回
array(
0 => array('a', 'b'),
1 => array('c', 'd'),
2 => array('e', 'f'),
3 => array('g', 'h'),
4 => array('i', 'j'),
5 => array('k', 'l'),
6 => array('m', 'n'),
7 => array('o', 'p'),
8 => array('q', 'r')
)
我该怎么做呢？感谢。
答案 0 :(得分：31)
这个简单的功能对你有用：
用法
$array = range("a", "r"); // same as your array
print_r(alternate_chunck($array,12));
输出
Array
(
[0] => Array
(
[0] => a
[1] => b
)
[1] => Array
(
[0] => c
[1] => d
)
[2] => Array
(
[0] => e
[1] => f
)
[3] => Array
(
[0] => g
[1] => h
)
[4] => Array
(
[0] => i
[1] => j
)
[5] => Array
(
[0] => k
[1] => l
)
[6] => Array
(
[0] => m
)
[7] => Array
(
[0] => n
)
[8] => Array
(
[0] => o
)
[9] => Array
(
[0] => p
)
[10] => Array
(
[0] => q
)
[11] => Array
(
[0] => r
)
)
更新以上内容对大多数情况可能没用...这里是另一种类型的块
$array = range("a", "r"); // same as your array
print_r(fill_chunck($array, 5));
输出
Array
(
[0] => Array
(
[0] => a
[1] => b
[2] => c
[3] => d
)
[1] => Array
(
[0] => e
[1] => f
[2] => g
[3] => h
)
[2] => Array
(
[0] => i
[1] => j
[2] => k
[3] => l
)
[3] => Array
(
[0] => m
[1] => n
[2] => o
[3] => p
)
[4] => Array
(
[0] => q
[1] => r
)
)
这将确保该组在任何时间都不超过另一个没有限制的5个元素
使用的功能
function alternate_chunck($array, $parts) {
$t = 0;
$result = array();
$max = ceil(count($array) / $parts);
foreach(array_chunk($array, $max) as $v) {
if ($t < $parts) {
$result[] = $v;
} else {
foreach($v as $d) {
$result[] = array($d);
}
}
$t += count($v);
}
return $result;
}
function fill_chunck($array, $parts) {
$t = 0;
$result = array_fill(0, $parts - 1, array());
$max = ceil(count($array) / $parts);
foreach($array as $v) {
count($result[$t]) >= $max and $t ++;
$result[$t][] = $v;
}
return $result;
}
答案 1 :(得分：5)
你说：
我在数据库中有13个类别，我想将它们分组为12个 阵列。如果有超过12个类别，那么 从第一个数组开始插入剩余的值。
这样可行，但如果输入数组中有更多元素，那么输出应该是什么？
$array = array('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm');
function s($array, $am) {
$r = array();
$d = count($array) - $am+1;
foreach ($array as $k => $v) {
if ($k < $d) {
if (!isset($r[0])) {
$r[0] = array($v);
} else {
$r[0] = array_merge($r[0], array($v));
}
} else {
$r[] = array($v);
}
}
return $r;
}
将返回
Array
(
[0] => Array
(
[0] => a
[1] => b
)
[1] => Array
(
[0] => c
)
[2] => Array
(
[0] => d
)
[3] => Array
(
[0] => e
)
[4] => Array
(
[0] => f
)
[5] => Array
(
[0] => g
)
[6] => Array
(
[0] => h
)
[7] => Array
(
[0] => i
)
[8] => Array
(
[0] => j
)
[9] => Array
(
[0] => k
)
[10] => Array
(
[0] => l
)
[11] => Array
(
[0] => m
)
)
答案 2 :(得分：2)
您可以使用array_chunk和array_merge解决此问题：
<?php
$array = array('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r');
$chunked_arr = array_chunk($array,12);
$j = 0;
for($i = 0; $i < count($chunked_arr[0]); $i++){
if(!($i % 2 == 0)){
$first_combined[$j][$i % 2] = $chunked_arr[0][$i];
$j++;
} else {
$first_combined[$j][$i % 2] = $chunked_arr[0][$i];
}
}
$merged_array = array_merge($first_combined, $chunked_arr[1]);
echo '<pre>';
print_r($merged_array);
?>
你会得到这样的结果：
Array
(
[0] => Array
(
[0] => a
[1] => b
)
[1] => Array
(
[0] => c
[1] => d
)
[2] => Array
(
[0] => e
[1] => f
)
[3] => Array
(
[0] => g
[1] => h
)
[4] => Array
(
[0] => i
[1] => j
)
[5] => Array
(
[0] => k
[1] => l
)
[6] => m
[7] => n
[8] => o
[9] => p
[10] => q
[11] => r
)
这正是你想要的。
答案 3 :(得分：1)
ceil(count($array) / $parts)会给2，所以每个数组都会填满2个项目，直到你没有剩下2个项目。因此最后一个有1个项目。当你在数组中有大量数据时，这将有效，但是当你有少量数据时，这种情况就不会那么多了。
答案 4 :(得分：1)
您所描述的不是array_chunk的用途。您应该使用array_slice()并自己计算要作为新数组结束的数组的哪些部分。 （并使用for循环迭代原始数组）
更新
一些可以帮助您的计算：
minimum_fill = floor(array_length / nr_buckets)
bigger_buckets_amount = array_length - (minimum_fill / nr_buckets)
填充存储桶的算法：
循环遍历数组，使用bigger_buckets_amount填充第一个(minimum_fill + 1)数量的存储桶，使用minimum_fill
答案 5 :(得分：1)
编译并查看它是否适合您：
<?php
$array = array('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm');
$sliceA = 0;
$sliceB = 2;
$final = array(array_slice($array, $sliceA, $sliceB));
for ($i=$sliceB; $i<sizeof($array); $i++)
{
$final[$sliceB-1] = array($array[$i]);
$sliceB++;
}
var_dump($final);
答案 6 :(得分：1)
<?php
$array = range('a','r');
$length = array(2=>6,1=>6); // 2=>6 means -- first six elements of new array will have 2 elements each and then, 1=>6 means -- next six elements of new array will have 1 element each
$target = array(); // or use [] in PHP 5.4
foreach($length as $i=>$times) {
while($times>0){
$target[] = array_splice($array, 0, $i);
$times--;
}
}
print_r($target);
?>
答案 7 :(得分：1)
这会为你做的！
在这里，我使用我的函数smallify（）将15个元素的数组分成3个数组，每个数组包含5个元素。
<?php
$bigArray = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
echo ("<pre>");
print_r (smallify($bigArray, 3));
echo ("<pre/>");
function smallify($arr, $numberOfSlices){
$sliceLength = sizeof($arr) /$numberOfSlices;
for($i=1; $i<=$numberOfSlices; $i++){
$arr1 = array_chunk($arr, $sliceLength*$i);
return $arr1;
unset($arr1);
}
}
?>
<强>结果
Array
(
[0] => Array
(
[0] => 1
[1] => 2
[2] => 3
[3] => 4
[4] => 5
)
[1] => Array
(
[0] => 6
[1] => 7
[2] => 8
[3] => 9
[4] => 10
)
[2] => Array
(
[0] => 11
[1] => 12
[2] => 13
[3] => 14
[4] => 15
)
)
答案 8 :(得分：0)
我认为问题是你在使用array_chunk时使用的是2的大小。这可确保创建的每个新数组都有两个项目（如果可能）。当你到达10时，这会导致函数耗尽变量以放入新数组。你可以在这里找到关于函数的手册http://php.net/manual/en/function.array-chunk.php希望这有帮助
答案 9 :(得分：0)
数学的魔力在于确定元素的哪一部分属于第一组块中的每一行都填充了所有列，以及哪些元素属于第二组（如果该组甚至应该存在），其中除最右边的列已填充。
让我画出我在说什么。 >标记了两个分块数组之间的分隔。
$size = 9; ------------- $size = 9; -------------
$maxrows = 4; 1 | A , B , C | $maxrow = 3; | A , B , C |
$columns = 3; > |-----------| $columns = 3; 1 | D , E , F |
$fullrows = 1; | D , E | $fullrows = 3; | G , H , I |
2 | F , G | > -------------
| H , I | 2 n/a
---------
$size = 18; --------- $size = 17; -------------------------------------
$maxrows = 12; | A , B | $maxrows = 2; 1 | A , B , C , D , E , F , G , H , I |
$columns = 2; | C , D | $columns = 9; > -------------------------------------
$fullrows = 6; | E , F | $fullrows = 1; 2 | J , K , L , M , N , O , P , Q |
1 | G , H | ---------------------------------
| I , J |
| K , L |
> ---------
| M |
| N |
| O |
2 | P |
| Q |
| R |
-----
代码：（Demo）
function double_chunk($array, $maxrows) {
$size = sizeof($array);
$columns = ceil($size / $maxrows);
$fullrows = $size - ($columns - 1) * $maxrows;
if ($fullrows == $maxrows) {
return array_chunk($array, $fullrows); // all columns have full rows, don't splice
}
return array_merge(
array_chunk(
array_splice($array, 0, $columns * $fullrows), // extract first set to chunk
$columns
),
array_chunk($array, $columns - 1) // chunk the leftovers
);
}
var_export(double_chunk(range('a', 'i'), 3));
如果您不介意迭代的array_splice()调用，这会更简短，并且可能更容易理解（也许不行）：
代码：（Demo）
function custom_chunk($array, $maxrows) {
$size = sizeof($array);
$columns = ceil($size / $maxrows);
$fullrows = $size - ($columns - 1) * $maxrows;
for ($i = 0; $i < $maxrows; ++$i) {
$result[] = array_splice($array, 0, ($i < $fullrows ? $columns : $columns - 1));
}
return $result;
}
var_export(custom_chunk(range('a', 'r'), 12));
答案 10 :(得分：0)
您可以尝试使用以下简单功能吗？
$ cols = array2cols（$ array，12）;
function array2cols($array,$n){
$groups = array();
for($i=0;$i<$n;$i++){
$groups[$i] = array();
}
$col = 0;
foreach($array as $row){
$groups[$col][] = $row;
$col = ($col+1)%$n;
}
return $groups;
}
答案 11 :(得分：0)
<?php
function slotify($array, $length)
{
// Create a placeholder array and calculate the number of items
// needed per slot (think card dealing LtoR).
for(
$slots = array_fill(0, $length, 0), $count=count($array), $i=0;
$i<$count;
$slots[$i % $length]++, $i++
);
// Now just take slices of the original array
// depending on the calculated slot number and place in our slots
foreach($slots as $k => $n) {
$slots[$k] = array_splice($array, 0, $n);
}
return $slots;
}
var_export(slotify(['a','b','c','d','e','f'], 4));
输出：
array (
0 =>
array (
0 => 'a',
1 => 'b',
),
1 =>
array (
0 => 'c',
1 => 'd',
),
2 =>
array (
0 => 'e',
),
3 =>
array (
0 => 'f',
),
)
上面的示例中，保存所需数量的中间数组$slots看起来像这样：
array (
0 => 2,
1 => 2,
2 => 1,
3 => 1,
)
如果您研究中间阵列的不同组合。您需要计算出块大小更改的边界点。我的解决方案趋向于以下方面，这几乎是mickmacusa的最终解决方案。但这需要了解问题。
function slotify($array, $length)
{
$count = count($array);
$chunk_size = ceil($count/$length);
$boundary = $count % $length;
if($boundary === 0)
$boundary = $length;
for($i=0; $i<$length; $i++) {
if($i === $boundary)
$chunk_size--;
$result[$i] = array_splice($array, 0, $chunk_size);
}
return $result;
}
可以进行进一步的细化，切片可能比拼接更有效，并且如果您可以在整个阵列中均匀分布，则可以进行快捷操作。