PHP Iterables

Introduction aux Iterables PHP

En PHP, un iterable est tout ce que vous pouvez parcourir avec foreach. Cela inclut deux types de valeurs :

1. Arrays — la structure de données courante qui contient une collection ordonnée de paires clé/valeur.
2. Objets Traversable — des objets que PHP sait parcourir, car ils implémentent l'interface intégrée Traversable (en pratique via Iterator ou IteratorAggregate, ou sous forme de générateur).

PHP 7.1 a ajouté le pseudo-type iterable pour vous permettre de déclarer « donnez-moi quelque chose que je peux parcourir avec foreach » sans vous soucier de savoir si l'appelant passe un array ou un objet. Cette page explique ce qui est considéré comme iterable, comment créer et parcourir chaque type, et quand utiliser les iterables paresseux que les générateurs offrent.

Ce chapitre s'appuie sur PHP Arrays et la boucle foreach. Si vous débutez avec l'un ou l'autre, lisez-les d'abord.

Les arrays : l'iterable le plus courant

Les arrays se déclinent en deux formes, la seule différence étant le type de clé utilisé :

• Un array indexé stocke des valeurs sous des clés entières automatiques, à partir de 0. Voir Indexed Arrays.
• Un array associatif utilise des chaînes de caractères (ou des entiers de votre choix) comme clés. Voir Associative Arrays.

Un seul array peut mélanger les deux styles, et les valeurs peuvent être de n'importe quel type de données.

Créer et accéder aux arrays

Créez un array avec des crochets, puis lisez une valeur via sa clé :

PHP définir et accéder à un array

<?php
$fruits  = ["apple", "banana", "cherry"];           // indexed
$student = ["name" => "John Doe", "age" => 25];      // associative

echo $fruits[0] . "\n";        // apple   (first element, index 0)
echo $student["name"] . "\n";  // John Doe

Résultat :

apple
John Doe

Notez que les arrays indexés commencent à zéro, donc $fruits[0] est le premier élément.

Parcourir un array avec foreach

foreach est la façon idiomatique de parcourir un iterable. Pour un array indexé, vous voulez généralement juste la valeur ; pour un array associatif, vous voulez typiquement la clé et la valeur :

PHP parcourir des arrays

<?php
$fruits  = ["apple", "banana", "cherry"];
$student = ["name" => "John Doe", "age" => 25];

foreach ($fruits as $fruit) {
    echo $fruit . "\n";
}

foreach ($student as $key => $value) {
    echo "$key: $value\n";
}

Résultat :

apple
banana
cherry
name: John Doe
age: 25

Fonctions utiles pour les arrays

PHP fournit des dizaines de fonctions pour les arrays. En voici quelques-unes que vous utiliserez constamment :

• array_keys($arr) — renvoie toutes les clés sous forme d'un nouvel array.
• array_values($arr) — renvoie toutes les valeurs, réindexées à partir de 0.
• count($arr) — renvoie le nombre d'éléments.
• sort($arr) — trie les valeurs par ordre croissant en place, retournant true en cas de succès (il ne retourne pas le array trié).
• in_array($needle, $arr) — true si la valeur existe.

PHP fonctions d'array en action

<?php
$scores = [40, 10, 30];

echo count($scores) . "\n";              // 3
print_r(array_keys($scores));            // [0, 1, 2]

sort($scores);                            // modifies $scores in place
print_r($scores);                         // [10, 30, 40]

Résultat :

3
Array
(
    [0] => 0
    [1] => 1
    [2] => 2
)
Array
(
    [0] => 10
    [1] => 30
    [2] => 40
)

Le pseudo-type iterable

iterable n'est pas une classe — c'est une indication de type qui signifie « array ou Traversable ». Utilisez-le sur un paramètre ou un type de retour lorsque votre fonction a seulement besoin de boucler, et que vous ne souhaitez pas forcer les appelants à convertir leurs données en array simple.

PHP indication de type iterable

<?php
function sumAll(iterable $numbers): int
{
    $total = 0;
    foreach ($numbers as $n) {
        $total += $n;
    }
    return $total;
}

echo sumAll([1, 2, 3]) . "\n";          // works with an array

function countToThree(): iterable {     // a generator is also iterable
    yield 1;
    yield 2;
    yield 3;
}
echo sumAll(countToThree()) . "\n";     // works with a Traversable too

Résultat :

6
6

L'avantage : sumAll() accepte un array ordinaire et un flux généré paresseusement sans aucun code supplémentaire. Voir PHP Functions pour en savoir plus sur les indications de type.

Générateurs : iterables paresseux

Un générateur est une fonction qui utilise yield à la place de return. Il produit des valeurs une par une, uniquement lorsque la boucle demande la suivante, donc il ne construit jamais toute la collection en mémoire. C'est idéal pour les séquences volumineuses ou infinies.

PHP exemple de générateur

<?php
function range_lazy(int $start, int $end): iterable
{
    for ($i = $start; $i <= $end; $i++) {
        yield $i;          // pauses here and resumes on the next iteration
    }
}

foreach (range_lazy(1, 5) as $value) {
    echo $value . " ";
}
echo "\n";

Résultat :

1 2 3 4 5

Comme rien n'est stocké, range_lazy(1, 1_000_000) utilise la même petite quantité de mémoire que range_lazy(1, 5).

Objets iterables personnalisés avec Iterator

Lorsque vous souhaitez un contrôle total sur la façon dont un objet est parcouru, implémentez l'interface Iterator. Elle requiert cinq méthodes que foreach appelle en coulisses : rewind(), valid(), current(), key() et next().

PHP Iterator personnalisé

<?php
class EvenNumbers implements Iterator
{
    private int $position = 0;

    public function __construct(private array $items) {}

    public function rewind(): void  { $this->position = 0; }
    public function valid(): bool   { return isset($this->items[$this->position]); }
    public function current(): mixed { return $this->items[$this->position]; }
    public function key(): mixed    { return $this->position; }
    public function next(): void    { $this->position++; }
}

$evens = new EvenNumbers([2, 4, 6]);
foreach ($evens as $n) {
    echo $n . " ";
}
echo "\n";

Résultat :

2 4 6

La plupart du temps, un générateur est plus simple qu'une classe Iterator complète — utilisez Iterator uniquement lorsque vous avez besoin d'un comportement de rembobinage/clé personnalisé ou que vous souhaitez exposer l'itération comme partie de l'API publique d'un objet.

Vérifier si une valeur est iterable

Utilisez is_iterable() pour tester à l'exécution si une valeur peut être passée à foreach :

PHP vérification is_iterable

<?php
var_dump(is_iterable([1, 2, 3]));                 // bool(true)
var_dump(is_iterable("a string"));                // bool(false)
var_dump(is_iterable((function () { yield 1; })())); // bool(true)

Résultat :

bool(true)
bool(false)
bool(true)

Conclusion

« Iterable » en PHP signifie simplement parcourable avec foreach — et cela couvre les arrays, les objets Iterator/IteratorAggregate et les générateurs. Utilisez des arrays simples pour les collections ordinaires, l'indication de type iterable pour écrire des fonctions qui acceptent n'importe lequel d'entre eux, et les générateurs lorsque la mémoire est importante ou que la séquence est volumineuse. Avec ces outils, vous pouvez modéliser les données efficacement et maintenir vos API flexibles.

Pratique