La classe IteratorIterator

(PHP 5 >= 5.1.0, PHP 7, PHP 8)

Introduction

Cet itérateur permet la conversion de n'importe quel objet Traversable en un itérateur. Il est important de comprendre que la plupart des classes qui n'implémentent pas l'interface Iterator, ne le font pas car elles ne disposent pas de toutes les méthodes des itérateurs. Si c'est le cas, des mécanismes doivent être mis en place pour l'éviter, car autrement, cela produirait des exceptions ou des erreurs fatales.

Synopsis de la classe

class IteratorIterator implements OuterIterator {

/* Méthodes */

public __construct(Traversable $iterator, ?string $class = null)

public current(): mixed

public getInnerIterator(): ?Iterator

public key(): mixed

public next(): void

public rewind(): void

public valid(): bool

}

Notes

Note:
Cette classe permet l'accès aux méthodes de l'itérateur interne via l'appel à la méthode magique __call.

Sommaire

IteratorIterator::__construct — Crée un itérateur à partir d'un objet traversable
IteratorIterator::current — Lit la valeur courante
IteratorIterator::getInnerIterator — Retourne l'itérateur interne
IteratorIterator::key — Lit la clé de l'élément courant
IteratorIterator::next — Avance au prochain élément
IteratorIterator::rewind — Retourne au premier élément
IteratorIterator::valid — Vérifie si l'élément actuel est valide

Improve This Page

Learn How To Improve This Page • Submit a Pull Request • Report a Bug

＋add a note

User Contributed Notes 4 notes

down

sven at rtbg dot de ¶

9 years ago

This iterator basically is only a wrapper around another iterator. It does nothing fancy, it simply forwards any calls of rewind(), next(), valid(), current() and key() to the inner iterator. This inner iterator can be fetched with getInnerIterator().

One special case: When passing an IteratorAggregate object, the getIterator() method of that object will be called and THAT iterator will be iterated over, and this will also be returned when calling getInnerIterator().

This class can be extended, so it's an ideal building block for your own classes that only want to modify one or two of the iterator methods, but not all.

Want to trim the strings returned by the current() method?

<?php

class TrimIterator extends IteratorIterator
{
    public function current() {
        return trim(parent::current());
    }
}

$innerIterator = new ArrayIterator(array('normal', ' trimmable '));

$trim = new TrimIterator($innerIterator);

foreach ($trim as $key => $value) {
    echo "Key:\n";
    var_dump($key);
    echo "Value:\n";
    var_dump($value);
    echo "---next---";
}
?>

Output:

Key:
int(0)
Value:
string(6) "normal"
---next---Key:
int(1)
Value:
string(9) "trimmable"
---next---

down

max-p at max-p dot me ¶

8 years ago

Little note for anyone that wants to emulate the behavior of foreach as close as possible in order to work with somewhat picky Traversable objects, without using foreach:

- Before starting the iteration, rewind() is called.
- For every iteration, the following methods are called on the iterator:
    - valid()
    - current()
    - key()
    - next()

Sounds like a silly thing to do put this way, but in my use case I needed to convert a Traversable database result cursor into a procedural-style cursor (hasNext + fetchArray) for backward compatibility, and the driver required every function to be called in the appropriate order.

down

thomas at gielfeldt dot dk ¶

7 years ago

IteratorIterator::current() does not invoke the inner iterator's current() method.

The inner iterator's current() method is invoked (and cached) on rewind() and next(). The same goes for key() and valid().

Example:
<?php

$i = new ArrayIterator(range(1,10));
$i = new IteratorIterator($i);
iterator_to_array($i); // Seek to the end
print "Valid: " . $i->valid() . "\n";
$i->append('test');
print "Valid: " . $i->valid() . "\n";
print "Current: " . $i->current() . "\n";

?>

Output:

Valid: 
Valid: 
Current: 

Whereas:
<?php

$i = new ArrayIterator(range(1,10));
iterator_to_array($i); // Seek to the end
print "Valid: " . $i->valid() . "\n";
$i->append('test');
print "Valid: " . $i->valid() . "\n";
print "Current: " . $i->current() . "\n";
?>

Output:

Valid: 
Valid: 1
Current: test

The reason being the way current(), key() and valid() are invoked by the IteratorIterator as mentioned above.

down

wallacemaxters at gmail dot lcom ¶

8 years ago

Another example of the efficiency for IteratorIterator is a small class for enumerate for iterations of an interator implementation.

Example:

<?php

class Enumerator extends IteratorIterator
{    
    /**
    * Initial value for enumerator
    * @param int  
    */
    protected $start = 0;

    /**
    * @param int
    */
    protected $key = 0;

    /**
    * @param Traversable $iterator
    * @param scalar $start
    */
    public function __construct(Traversable $iterator, $start = 0)
    {
        parent::__construct($iterator);

        $this->start = $start;

        $this->key = $this->start;
    }

    public function key()var_dump
    {
        return $this->key;
    }

    public function next()
    {
        ++$this->key;

        parent::next();
    }

    public function rewind()
    {
        $this->key = $this->start;

        parent::rewind();
    }

}
?>

This produces:

<?php

$enumerator = new Enumerator(
       new ArrayIterator(['php', 'java', 'python']); 7000
);

print_r(iterator_to_array($enumerator));

/*
*    array(3) { 
           7000 => 'php',
           7001 => 'java',
           7002 => 'python'
     }
*/

?>

＋add a note