---
title: "Comprendre et utiliser les itérateurs en PHP"
date: 2024-10-09T09:54:16.000Z
canonical: https://www.ekino.fr/publications/comprendre-et-utiliser-les-iterateurs-en-php/
---

![](https://www.ekino.fr/media/original/0000/00/2e053110-d081-8eb8-5fb2-434ce8eb392d.jpg)

L’introduction des itérateurs dans la version 5 de ***PHP*** en 2004 a considérablement amélioré la méthodologie de manipulation de grandes quantités de données de manière performante et organisée.

L’un des avantages les plus importants de l’utilisation des itérateurs réside dans la manière dont la mémoire est gérée en arrière-plan. Le secret de cette mécanique repose sur le fait que les itérables ne sont jamais chargés entièrement dans la mémoire, seulement la valeur de l’itération courante. C’est grâce à cette mécanique qu’il est possible de parcourir de gros itérables sans saturer la mémoire.

Une multitude [d’itérateurs](https://www.php.net/manual/en/spl.iterators.php) sont déjà disponibles de base dans la [Standard PHP Library (SPL)](https://www.php.net/manual/en/book.spl.php), il vaut donc la peine de les [consulter](https://www.php.net/manual/en/spl.iterators.php) avant de se lancer dans la création d’un itérateur personnalisé.

Regardons l’utilisation de l’[ArrayIterator](https://www.php.net/manual/fr/class.arrayiterator.php), proposé par la [SPL](https://www.php.net/manual/en/book.spl.php) :

```
$arrayIterator = new ArrayIterator([
  "firstIterationKey"  => "FirstIterationValue",
  "secondIterationKey" => "SecondIterationValue",
  "thirdIterationKey"  => "ThirdIterationValue",
]);

foreach($arrayIterator as $key => $value) {
  // $key   string(17) "firstIterationKey"
  // $value string(19) "FirstIterationValue"
  // ...
}
```

et oui… c’est aussi simple que ça. Il suffit simplement de l’utiliser avec un **foreach**, qui se charge d'appeler les méthodes qui seront expliquées par la suite, pour faire avancer l’itération.

Maintenant, imaginons qu’aucun des itérateurs proposés par la [SPL](https://www.php.net/manual/en/book.spl.php) ne corresponde à nos besoins. Comment mentionné précédemment, nous pouvons simplement créer notre propre iterator en implémentant l’interface **Iterator**.

Quatre méthodes sont imposées par l’interface **Iterator**. Voyons quelles sont ces quatre méthodes et quel est leur rôle :

```
class MyCutomIterator implements Iterator {
    // Retourne la valeur de l'itération courante
    public current(): mixed

    // Retourne la position de l'iteration courante 
    public key(): mixed

    // Permet de passer à l'itération suivante
    public next(): void
    
    // Permet de reinitialiser le pointeur
    public rewind(): void
    
    // Méthode en charge de verifier si la position du prochaine iteration existe.
    public valid(): bool
}
```

Maintenant que nous savons comment utiliser les itérateurs, regardons ce qui se passe en coulisses.

Les étapes suivantes vont décrire comment **foreach** gère le parcours d’un itérable :

**Première étape:* ***Initialisation du **foreach**.

**Deuxième étape :** Vérification de la structure de données reçue pour déterminer si elle est traversable. ***À noter :**** seules les structures de données qui implémentent l’interface Traversable peuvent être parcourues avec ****foreach****.*

**Troisième étape : **À cette étape, PHP crée un itérateur pour cette structure de données si elle est [traversable](https://www.php.net/manual/fr/class.traversable.php). ***À noter :*** *que si la structure de données reçue implémente déjà l’interface *[*Iterator*](https://www.php.net/manual/fr/class.iterator.php)*, PHP considère que la structure est prête à être parcourue. Sinon, PHP crée un itérateur pour elle. Il ne faut pas oublier que ****foreach**** fonctionne uniquement avec des iterables.*

**Quatrième étape :** La méthode ***rewind()*** est appelée pour initialiser le pointeur. Celle-ci est nécessaire pour s’assurer que l’itération commence depuis le début de l’itérable.

**Cinquième étape :** La méthode ***valid()*** est appelée pour savoir si la prochaine position de l’itérable existe. Dans le cas où ***valid()*** retourne ***true***, l’itération se poursuit. Dans le cas contraire, cela signifie qu’il n’y a plus de position, donc l’itération se termine.

**Sixième étape : **La méthode ***current()*** est appelée pour récupérer la valeur de l’itération courante. C’est à ce moment-là que ***$value*** et **$key** sont populés.

**Septième étape :** Le code à “l’intérieur” du **foreach** est exécuté.

**Huitième étape :** La méthode ***next()*** est appelée pour faire avancer le pointeur à la prochaine position de l’itérable.

Et voilà comment fonctionnent les itérateurs. Au final, on peut dire qu’à partir du moment où l’on utilise le **foreach**, on utilise les itérateurs sans s’en rendre compte, finalement.

Si cet article t’a plu, n’hésite pas à lire mon article sur [Sonata Exporter](https://medium.com/@rolland.csatari_42973/3a06f3394f26)

---

[Comprendre et utiliser les itérateurs en PHP](https://medium.com/ekino-france/comprendre-et-utiliser-les-it%C3%A9rateurs-en-php-22a864b3bfe2) was originally published in [ekino-france](https://medium.com/ekino-france) on Medium, where people are continuing the conversation by highlighting and responding to this story.