Multidimensional Arrays Nested to Unlimited Depth

Question

I have a multidimensional array nested to an unknown/unlimited depth. I\'d like to be able to loop through every element. I don\'t want to use, foreach(){foreach(){for

Answer 1

I'm eventually looking for all nested arrays called "xyz". Has anyone got any suggestions?

Sure. Building on the suggestions to use some iterators, you can do:

$iterator = new RecursiveIteratorIterator(
    new RecursiveArrayIterator($array),
    RecursiveIteratorIterator::SELF_FIRST
);
foreach ($iterator as $key => $item) {
    if (is_array($item) && $key === 'xyz') {
        echo "Found xyz: ";
        var_dump($item);
    }
}

The important difference between the other answers and this being that the RecursiveIteratorIterator::SELF_FIRST flag is being employed to make the non-leaf (i.e. parent) items (i.e. arrays) visible when iterating.

You could also make use of a ParentIterator around the array iterator, rather than checking for arrays within the loop, to make the latter a little tidier.

Answer 2

Take a look to the RecursiveIteratorIterator interface.

$interface = new RecursiveIteratorIterator( new RecursiveArrayIterator($your_array) );
foreach($interface as $k=>$v) { /* your function*/  }

Answer 3

Have you thought about using array_walk_recursive for this?

Another (slower) approach would be to flatten the array first before performing a search, ie:

$myarray = array('a','b',array(array(array('x'),'y','z')),array(array('p')));

function array_flatten($array,$return)
{
    for($x = 0; $x <= count($array); $x++)
    {
        if(is_array($array[$x]))
        {
            $return = array_flatten($array[$x],$return);
        }
        else
        {
            if($array[$x])
            {
                $return[] = $array[$x];
            }
        }
    }
    return $return;
}

$res = array_flatten($myarray,array());

Or, for a recursive search, see here for an example:

function arrayRecursiveSearch($needle, $haystack, $path=""){
  if(!is_array($haystack)){
    die("second argument is not array");
  }

  global $matches;

  foreach($haystack as $key=>$value)
  {
    if(preg_match("/$needle/i", $key)){
      $matches[] = array($path . "$key/", "KEY: $key");
    }

    if(is_array($value)){
      $path .= "$key/";
      arrayRecursiveSearch($needle, $value, $path);
      unset($path);
    }else{
      if(preg_match("/$needle/i", $value)){
        $matches[] = array($path . "$key/", "VALUE: $value");
      }
    }
  }

  return $matches;
}

$arr = array("Asia"=>array('rambutan','duku'),
              "Australia"=>array('pear','kiwi'),
              "Arab"=>array('kurma'));

print_r(arrayRecursiveSearch("ra",$arr));

Answer 4

Using the comments above, I've found the answer:

function findXyz($array){
    foreach($array as $foo=>$bar){
      if (is_array($bar)){
         if ($bar["xyz"]){
             echo "<br />The array of xyz has now been found";
             print_r($bar['xyz']);
         }else{
            findXyz($bar);   
         } 
      }
    } 
}
findXyz($myarray);

This loops through all nested arrays and looks for any element who has a sub-array of xyz, as per my original request. array_walk_array and RecursiveIteratorIterator were unable to achieve this.

Answer 5

There is a vast difference between unknown and unlimited. However, you can make use of the SPL Iterators instead of using multiple nested foreach loops.

Example:

$array_obj = new RecursiveIteratorIterator(new RecursiveArrayIterator($array));
foreach($array_obj as $key => $value) {
   echo $value;
}

Answer 6

Recursion.

Write a function that walks one array; for each element that is also an array, it calls itself; otherwise, when it finds the target string, it returns.