PHP fournit une façon de définir les objets de manière à ce qu'on puisse parcourir une liste de membres avec une structure foreach. Par défaut, toutes les propriétés visibles seront utilisées pour le parcours.
Exemple #1 Parcours d'objet simple
<?php
class MyClass
{
public $var1 = 'valeur 1';
public $var2 = 'valeur 2';
public $var3 = 'valeur 3';
protected $protected = 'variable protégée';
private $private = 'variable privée';
function iterateVisible() {
echo "MyClass::iterateVisible:\n";
foreach($this as $key => $value) {
print "$key => $value\n";
}
}
}
$class = new MyClass();
foreach($class as $key => $value) {
print "$key => $value\n";
}
echo "\n";
$class->iterateVisible();
L'exemple ci-dessus va afficher :
var1 => valeur 1 var2 => valeur 2 var3 => valeur 3 MyClass::iterateVisible: var1 => valeur 1 var2 => valeur 2 var3 => valeur 3 protected => variable protégée private => variable privée
Comme nous le montre l'affichage, l'itération foreach affiche toutes les variables visibles disponibles. Pour aller plus loin, vous pouvez implémenter l'interface interne de PHP nommée Iterator. Ceci permet de déterminer comment l'objet doit être parcouru.
Exemple #2 Itération d'un objet implémentant un itérateur
<?php
class MyIterator implements Iterator
{
private $var = array();
private $index = 0;
public function __construct($array)
{
if (is_array($array)) {
$this->var = $array;
}
}
public function rewind()
{
echo "rembobinage\n";
$this->index = 0;
}
public function current()
{
$k = array_keys($this->var);
$var = $this->var[$k[$this->index]];
echo "actuel : $var\n";
return $var;
}
public function key()
{
$k = array_keys($this->var);
$var = $k[$this->index];
echo "clé : $var\n";
return $var;
}
public function next()
{
$k = array_keys($this->var);
if (isset($k[++$this->index])) {
$var = $this->var[$k[$this->index]];
echo "suivant : $var\n";
return $var;
} else {
echo "suivant :\n";
return false;
}
}
public function valid()
{
$k = array_keys($this->var);
$var = isset($k[$this->index]);
echo "valide : {$var}\n";
return $var;
}
}
$values = array(1,2,3);
$it = new MyIterator($values);
foreach ($it as $a => $b) {
print "$a: $b\n";
}
?>
L'exemple ci-dessus va afficher :
rembobinage valide : 1 actuel : 1 clé : 0 0: 1 suivant : 2 valide : 1 actuel : 2 clé : 1 1: 2 suivant : 3 valide : 1 actuel : 3 clé : 2 2: 3 suivant : (il n'y en a plus) valide :
Vous pouvez également définir votre classe de façon à ce qu'elle n'ait pas besoin de définir toutes les fonctions Iterator en implémentant simplement l'interface PHP IteratorAggregate.
Exemple #3 Itération d'un objet implémentant IteratorAggregate
<?php
class MyCollection implements IteratorAggregate
{
private $items = array();
private $count = 0;
// Définition requise de l'interface IteratorAggregate
public function getIterator() {
return new MyIterator($this->items);
}
public function add($value) {
$this->items[$this->count++] = $value;
}
}
$coll = new MyCollection();
$coll->add('valeur 1');
$coll->add('valeur 2');
$coll->add('valeur 3');
foreach ($coll as $key => $val) {
echo "clé/valeur : [$key -> $val]\n\n";
}
?>
L'exemple ci-dessus va afficher :
rembobinage actuel : valeur 1 valide : 1 actuel : valeur 1 clé : 0 clé/valeur : [0 -> valeur 1] suivant : valeur 2 actuel : valeur 2 valide : 1 actuel : valeur 2 clé : 1 clé/valeur : [1 -> valeur 2] suivant : valeur 3 actuel : valeur 3 valide : 1 actuel : valeur 3 clé : 2 clé/valeur : [2 -> valeur 3] suivant : actuel : valide :
Note:
Pour plus d'exemples sur le parcours d'objets, lisez la section sur l'extension SPL.