Les classes et les objets
PHP Manual

Parcours d'objets

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.


Les classes et les objets
PHP Manual