PHP 7.0.6 Released

    The RecursiveIteratorIterator class

    (PHP 5, PHP 7)

    Introduction

    Can be used to iterate through recursive iterators.

    Class synopsis

    RecursiveIteratorIterator implements OuterIterator {
    /* Constants */
    const integer LEAVES_ONLY = 0 ;
    const integer SELF_FIRST = 1 ;
    const integer CHILD_FIRST = 2 ;
    const integer CATCH_GET_CHILD = 16 ;
    /* Methods */
    public void beginChildren ( void )
    public void beginIteration ( void )
    public RecursiveIterator callGetChildren ( void )
    public bool callHasChildren ( void )
    public __construct ( Traversable $iterator [, int $mode = RecursiveIteratorIterator::LEAVES_ONLY [, int $flags = 0 ]] )
    public mixed current ( void )
    public void endChildren ( void )
    public void endIteration ( void )
    public int getDepth ( void )
    public iterator getInnerIterator ( void )
    public mixed getMaxDepth ( void )
    public RecursiveIterator getSubIterator ([ int $level ] )
    public mixed key ( void )
    public void next ( void )
    public void nextElement ( void )
    public void rewind ( void )
    public void setMaxDepth ([ string $max_depth = -1 ] )
    public bool valid ( void )
    /* Inherited methods */
    public Iterator OuterIterator::getInnerIterator ( void )
    }

    Predefined Constants

    RecursiveIteratorIterator::LEAVES_ONLY

    RecursiveIteratorIterator::SELF_FIRST

    RecursiveIteratorIterator::CHILD_FIRST

    RecursiveIteratorIterator::CATCH_GET_CHILD

    Table of Contents

    User Contributed Notes

    zlobnygrif at gmail dot com
    2 years ago
    Some speed tests
    <?php
    $timer     = function ($name = 'default', $unset_timer = TRUE)
    {
        static     $timers = array();
       
        if ( isset(     $timers[ $name ] ) )
        {
            list(    $s_sec, $s_mic) = explode(' ', $timers[ $name ]);
            list(    $e_sec, $e_mic) = explode(' ', microtime());
           
            if (     $unset_timer )
                unset(     $timers[ $name ] );
           
            return     $e_sec - $s_sec + ( $e_mic - $s_mic );
        }
       
            $timers[ $name ] = microtime();
    };

    function     f1 ($array) {
            $iterator = new RecursiveIteratorIterator(new RecursiveArrayIterator($array), RecursiveIteratorIterator::SELF_FIRST);

        foreach (     $iterator as $key => $value ) {
            if (     is_array($value) )
                continue;
        }
    }

    function     f2($array) {
        foreach (     $array as $key => $value ) {
            if (     is_array($value) )
                    f2($value);
        }
    }

    foreach ( [    100, 1000, 10000, 100000, 1000000] as $num )
    {
            $array = [];
       
        for (     $i = 0; ++$i < $num; )
                $array[] = [1,2,3=>[4,5,6=>[7,8,9=>10,11,12=>[13,14,15=>[16,17,18]]]]];
       
            $timer();
            f1($array);
            printf("RecursiveIteratorIterator: %7d elements -> %.3f sec\n", $num, $timer());
       
            $timer();
            f2($array);
            printf("Recursive function       : %7d elements -> %.3f sec\n", $num, $timer());
    }

    ?>

    Output (PHP 5.4.9-4ubuntu2.1 (cli) (built: Jun 11 2013 13:10:01))
    =======================
    RecursiveIteratorIterator:     100 elements -> 0.007 sec
    Recursive function       :     100 elements -> 0.002 sec
    RecursiveIteratorIterator:    1000 elements -> 0.036 sec
    Recursive function       :    1000 elements -> 0.024 sec
    RecursiveIteratorIterator:   10000 elements -> 0.425 sec
    Recursive function       :   10000 elements -> 0.263 sec
    RecursiveIteratorIterator:  100000 elements -> 8.153 sec
    Recursive function       :  100000 elements -> 2.654 sec
    RecursiveIteratorIterator: 1000000 elements -> 474.483 sec
    Recursive function       : 1000000 elements -> 26.872 sec

    For one million elements recursive function is more quickly!
    Adil Baig @ AIdezigns
    4 years ago
    A very important thing to note about \RecursiveIteratorIterator is that it returns a flattened array when used with the iterator_to_array function. Ex:

    <?php
    $arr     = array('Zero', 'name'=>'Adil', 'address' => array( 'city'=>'Dubai', 'tel' => array('int' => 971, 'tel'=>12345487)), '' => 'nothing');

    $iterator = new \RecursiveIteratorIterator(new \RecursiveArrayIterator($arr));
    var_dump(iterator_to_array($iterator,true));
    ?>

    This code will return :

    array(6) {
      [0]=>
      string(4) "Zero"
      ["name"]=>
      string(4) "Adil"
      ["city"]=>
      string(5) "Dubai"
      ["int"]=>
      int(91)
      ["tel"]=>
      int(12345487)
      [""]=>
      string(7) "nothing"
    }

    To get the non-flattened proper array use the getArrayCopy() method, like so :

    $iterator->getArrayCopy()

    This will return

    array(4) {
      [0]=>
      string(4) "Zero"
      ["name"]=>
      string(4) "Adil"
      ["address"]=>
      array(2) {
        ["city"]=>
        string(5) "Dubai"
        ["tel"]=>
        array(2) {
          ["int"]=>
          int(91)
          ["tel"]=>
          int(12345487)
        }
      }
      [""]=>
      string(7) "nothing"
    }
    aidan at php dot net
    6 years ago
    This example demonstrates using the getDepth() method with a RecursiveArrayIterator.

    <?php
    $tree     = array();
    $tree[1][2][3] = 'lemon';
    $tree[1][4] = 'melon';
    $tree[2][3] = 'orange';
    $tree[2][5] = 'grape';
    $tree[3] = 'pineapple';

    print_r($tree);

    $arrayiter = new RecursiveArrayIterator($tree);
    $iteriter = new RecursiveIteratorIterator($arrayiter);

    foreach (    $iteriter as $key => $value) {
          $d = $iteriter->getDepth();
      echo     "depth=$d k=$key v=$value\n";
    }
    ?>

    The output of this would be:

    Array
    (
        [1] => Array
            (
                [2] => Array
                    (
                        [3] => lemon
                    )

                [4] => melon
            )

        [2] => Array
            (
                [3] => orange
                [5] => grape
            )

        [3] => pineapple
    )

    depth=2 k=3 v=lemon
    depth=1 k=4 v=melon
    depth=1 k=3 v=orange
    depth=1 k=5 v=grape
    depth=0 k=3 v=pineapple
    fengdingbo at gmail dot com
    2 years ago
    if you want traversal directory。
    <?php
    foreach (new RecursiveIteratorIterator(new RecursiveDirectoryIterator("./")) as $key=>$val)
    {
        echo     $key,"=>",$val,"\n";
    }
    ?>
    Michiel Brandenburg
    6 years ago
    You can use this to quickly find all the files (recursively) in a certain directory. This beats maintaining a stack yourself.
    <?php
    $directory     = "/tmp/";
    $fileSPLObjects =  new RecursiveIteratorIterator(
                    new     RecursiveDirectoryIterator($directory),
                        RecursiveIteratorIterator::CHILD_FIRST
                    );
    try {
        foreach(     $fileSPLObjects as $fullFileName => $fileSPLObject ) {
            print     $fullFileName . " " . $fileSPLObject->getFilename() . "\n";
        }
    }
    catch (    UnexpectedValueException $e) {
            printf("Directory [%s] contained a directory we can not recurse into", $directory);
    }
    ?>
    Note: if there is a directory contained within the directory you are searching in that you have no access to read an UnexpectedValueException will be thrown (leaving you with an empty list).
    Note: objects returned are SPLFileObjects
    gerry at king-foo dot be
    1 year ago
    Carefull when using iterator_to_array(). Because it flattens down your subiterators, elements with the same keys will overwrite eachother.

    For example:

    <?php

    $iterator     = new RecursiveIteratorIterator(
        new     RecursiveArrayIterator([
            [    'foo', 'bar'],
            [    'baz', 'qux']
        ])
    );

    foreach (    $iterator as $element) {
        echo     $element;
    }

    ?>

    This will output all 4 elements as expected:

    string(3) "foo"
    string(3) "bar"
    string(3) "baz"
    string(3) "qux"

    While doing:

    <?php

    var_dump    (iterator_to_array($iterator));

    ?>

    will output an array with only the last 2 elements:

    array(2) {
      [0]=>
      string(3) "baz"
      [1]=>
      string(3) "qux"
    }
    Tom
    5 years ago
    This class operates on a tree of elements, which is build by nesting recursive iterators into one another.

    Thus you might say it is an iterator over iterators. While traversing those, the class pushes the iterators on a stack while traversing down to a leaf and removes them from the stack while going back up.
    jhonatan dot teixeira at gmail dot com
    27 days ago
    Note that this class will first iterate your entire tree and build the graph before going into your foreach. That's propably how it can iterate your leaves first or only your leaves. and that's must be the reason its slower than commom recursive functions.

    Beware of that wen you have a tree that can go into a infinite loop, in some cases you know your tree has a infinite loop, but you are looking for something inside it and are breaking the loop wne found, this class wen used on these cases will get stuck into an internal infinite loop.
    crashrox at gmail dot com
    7 years ago
    Recursive multidimensional array flatten using SPL

    <?php
    function array_flatten_recursive($array) {
        if(    $array) {
                $flat = array();
            foreach(new     RecursiveIteratorIterator(new RecursiveArrayIterator($array), RecursiveIteratorIterator::SELF_FIRST) as $key=>$value) {
                if(!    is_array($value)) {
                        $flat[] = $value;
                }
            }
           
            return     $flat;
        } else {
            return     false;
        }
    }

    $array = array(
            'A' => array('B' => array( 1, 2, 3, 4, 5)),
            'C' => array( 6,7,8,9)
    );

    print_r(array_flatten_recursive($array));
    ?>
    -- Returns:
    Array (
        [0] => 1
        [1] => 2
        [2] => 3
        [3] => 4
        [4] => 5
        [5] => 6
        [6] => 7
        [7] => 8
        [8] => 9
    )
    To Top