Am meisten verschachtelte Arrays

Question

Ich habe es mit einer Art von Writerblock zu tun und ich kann nicht herausfinden, wie man die am tiefsten verschachtelten (Sub-) Arrays innerhalb eines Arrays bekommt.

Wenn ich habe folgende Array:

$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)), 
); 

ich brauche die folgende (Sub) Array von der testarray zu extrahieren:

• array (5,6,7)
• Array (10,11,12)

die in diesem Beispiel 3 Ebenen tief sind.

Ich habe viele Dinge mit foreach in rekursiven Funktionen usw. ausprobiert, aber das Endergebnis endete immer in keinem Ergebnis, allen Elementen oder dem letzten iterierten Element.

Ich erwarte keine vollständig codierte Antwort (noch haha), aber kann mir bitte jemand Anweisungen geben, wie ich meine Ziele erreichen kann?

Wenn ich etwas codiert habe, bin ich gerne bereit, spezifischere Fragen zu stellen oder die Lösung zu liefern.

Answer 1

Erweiterte Lösung mit RecursiveIteratorIterator Klasse:

$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); 

Der Ausgang:

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

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

Sie können diesen Ansatz in eine benannte Funktion wickeln und es verwenden, um die deepmost Arrays für immer.

Viel Spaß!)

Answer 2

Roman Lösung scheint zu arbeiten, aber ich habe Mühe, diese Art von Methode zu lesen. Hier ist meine Version, die tiefsten Sub-Arrays zu finden.

Siehe meine Inline-Kommentare für die Erklärung der einzelnen Schritte. Grundsätzlich überprüft es jedes Array auf Unterarrays, iteriert/rekursiv, wenn möglich, und speichert Subarrays mit dem Zähler level als Schlüssel.

Code: (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)); 

Ausgang:

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

... es wird auch auf eindimensionale Arrays arbeiten. (Demo)