Question

我正在处理一种writersblock，我无法弄清楚如何在数组中获得最深层嵌套（子）数组。

如果我有以下数组：

$testArray= array(
    'test1' => 'SingleValue1',
    'test2' => 'SingleValue2',
    'test3' => array(0,1,2),
    'test4' => array(array(3,4,array(5,6,7)), array(8,9,array(10,11,12)),13,14),
    'test5' => array(15,16,17, array(18,19,20)),
);

我需要从testArray中提取以下（子）数组：

阵列（5,6,7）
阵列（10,11,12）

这个例子中有3个级别。

我在递归函数等中使用foreach尝试过很多东西，但最终结果总是没有结果，所有元素或最后一个迭代元素。

我不期待一个完全编码的答案（但哈哈），但有人可以给我指示如何实现我的目标吗？

当我编写某些内容时，我很乐意提出更具体的问题或提供解决方案。

Answer 1

RecursiveIteratorIterator类的扩展解决方案：

$testArray= array(
    'test1' => 'SingleValue1',
    'test2' => 'SingleValue2',
    'test3' => array(0,1,2),
    'test4' => array(array(3,4,array(5,6,7)), array(8,9,array(10,11,12)),13,14),
    'test5' => array(15,16,17, array(18,19,20)),
);

$it = new \RecursiveArrayIterator($testArray);
$it = new \RecursiveIteratorIterator($it, \RecursiveIteratorIterator::CHILD_FIRST);
$max_depth = 0;
$items = $deepmost = [];

foreach ($it as $item) {
    $depth = $it->getDepth();        // current subiterator depth
    if ($depth > $max_depth) {       // determining max depth
        $max_depth = $depth;
        $items = [];
    }
    if (is_array($item)) {
        $items[$depth][] = $item;
    }
}

if ($items) {
    $max_key = max(array_keys($items));  // get max key pointing to the max depth
    $deepmost = $items[$max_key];
    unset($items);
}
print_r($deepmost);

输出：

Array
(
    [0] => Array
        (
            [0] => 5
            [1] => 6
            [2] => 7
        )

    [1] => Array
        (
            [0] => 10
            [1] => 11
            [2] => 12
        )
)

您可以将此方法包装到命名函数中，并使用它来获取最深层数组。

享受！）

Answer 2

Roman的解决方案似乎有效，但我很难阅读这种方法。这是我找到最深层子阵列的版本。

有关每个步骤的说明，请参阅我的内联注释。基本上，它检查每个数组的子数组，然后在可能的情况下迭代/递归，并使用level计数器作为键存储子数组。

代码：（Demo）

function deepestArrays($array,$level=0,&$lowest=[]){
    if(sizeof($subarrays=array_filter($array,function($v){return is_array($v);}))){  // isolate subarrays, iterate if any
        foreach($subarrays as $subs){
            deepestArrays($subs,$level+1,$lowest);  // recurse each subarray
        }
    }else{
       if(!sizeof($lowest) || ($lowest_level=key($lowest))==$level){  // if $levels is empty or current $level equals $lowest_level
            $lowest[$level][]=$array;  // append the array to the results
        }elseif($lowest_level<$level){
            $lowest=[$level=>[$array]]; // clear previous storage, store new lowest array
        }
    }
    return current($lowest);  // use current() to strip the temporary level identifying key
}

var_export(deepestArrays($testArray));

输出：

array (
  0 => 
  array (
    0 => 5,
    1 => 6,
    2 => 7,
  ),
  1 => 
  array (
    0 => 10,
    1 => 11,
    2 => 12,
  ),
)

......它甚至可以用于一维数组。（Demo）

获得最深层嵌套的数组

2 个答案: