1.3 · Boucles (for, while, foreach)

Niveau 1 · Bases du langage

1.3Boucles (for, while, foreach)

Objectif : répéter des traitements et parcourir des collections.
Temps estimé : 10 min

Les boucles permettent de RÉPÉTER un traitement, plutôt que d'écrire le même code plusieurs fois — indispensable dès qu'on manipule des collections ou qu'on répète une action. PHP offre plusieurs types de boucles, chacun adapté à un besoin. Le for : quand on connaît le NOMBRE de répétitions (ou qu'on itère avec un compteur) — for ($i = 0; $i < 10; $i++) { ... } (initialisation ; condition de continuation ; incrément). Il exécute le bloc tant que la condition est vraie, en incrémentant le compteur. Le while : quand on répète TANT QU'une condition est vraie (nombre de répétitions inconnu à l'avance) — while (condition) { ... }. Le do...while : similaire, mais exécute le bloc AU MOINS UNE FOIS avant de tester la condition (le test est à la fin). Ces boucles sont universelles (présentes dans tous les langages).

La boucle la plus caractéristique et utile en PHP est le foreach : conçue spécifiquement pour PARCOURIR les éléments d'un tableau (ou d'un objet itérable) — de loin la boucle la plus utilisée en pratique, car on manipule constamment des tableaux (résultats de base de données, listes, données de formulaire). Deux formes : foreach ($tableau as $valeur) { ... } (parcourt chaque VALEUR) et foreach ($tableau as $cle => $valeur) { ... } (parcourt chaque paire CLÉ → VALEUR, utile pour les tableaux associatifs). Par exemple, afficher tous les produits d'une liste, ou toutes les lignes d'un résultat de requête, se fait naturellement avec un foreach. C'est l'outil pour « faire quelque chose pour chaque élément ». Deux instructions de contrôle accompagnent les boucles : break (SORTIR de la boucle immédiatement — par exemple, arrêter dès qu'on a trouvé ce qu'on cherche) et continue (PASSER à l'itération suivante sans finir l'actuelle — par exemple, ignorer certains éléments). Points de vigilance : (1) la boucle INFINIE — si la condition d'un while ne devient jamais fausse (ou si on oublie d'incrémenter dans un for/while), la boucle tourne indéfiniment et bloque le script ; assurez-vous toujours que la condition finira par être fausse. (2) Comme pour les conditions, la syntaxe ALTERNATIVE (foreach (...): ... endforeach;) est privilégiée dans les TEMPLATES HTML (plus lisible mêlée au HTML). Les boucles, et surtout le foreach, sont omniprésentes : dès que vous affichez une liste, traitez plusieurs éléments, ou répétez une action, vous utilisez une boucle. Maîtriser for (compteur), while (condition), foreach (parcourir un tableau) et break/continue est essentiel — c'est ce qui permet de traiter des ENSEMBLES de données efficacement, au cœur de la plupart des applications web (afficher des résultats, traiter des collections).

Vocabulaire de la section

Boucle
Répète un traitement plutôt que de dupliquer le code ; indispensable pour manipuler des collections ou répéter une action.
for
Boucle avec compteur, quand on connaît le nombre de répétitions : `for ($i = 0; $i < 10; $i++) { ... }` (initialisation ; condition ; incrément).
while / do...while
while : répète TANT QU'une condition est vraie (nombre inconnu). do...while : exécute au moins une fois (test à la fin).
foreach
Boucle pour PARCOURIR un tableau (la plus utilisée) : `foreach ($tab as $valeur)` (chaque valeur) ou `foreach ($tab as $cle => $valeur)` (paires clé → valeur).
break / continue
break : SORT de la boucle immédiatement. continue : PASSE à l'itération suivante. Attention aux boucles INFINIES (condition qui ne devient jamais fausse).
Vérifiez votre compréhension

Quelle est la boucle la plus caractéristique et utilisée en PHP ?

Tutoriel 1.3
Tutos « 1.3 » PHP boucle for while foreach itération (recherche)
Cliquer pour voir les résultats à jour ↗

En pratique — Répéter et parcourir avec les boucles

  1. Écrivez une boucle for (ex. afficher les nombres de 1 à 10) et une boucle while (répéter tant qu'une condition est vraie).
  2. Parcourez un tableau avec foreach : `foreach ($produits as $produit) { ... }`, puis avec clé => valeur sur un tableau associatif.
  3. Utilisez break (sortir dès qu'on trouve un élément) et continue (ignorer certains éléments) dans une boucle.
  4. Vérifiez qu'aucune boucle n'est infinie (la condition finit par être fausse) et repérez la syntaxe alternative `foreach (...): ... endforeach;` pour les templates.
Vous répétez des traitements et parcourez des collections avec for, while et surtout foreach (le plus utilisé), en contrôlant le flux avec break/continue — au cœur du traitement de données.

Points clés à retenir

  • Les BOUCLES répètent un traitement : `for` (avec compteur, nombre connu), `while` (tant qu'une condition est vraie, nombre inconnu), `do...while` (au moins une fois).
  • FOREACH est LA boucle clé de PHP : parcourir un TABLEAU — `foreach ($tab as $valeur)` ou `foreach ($tab as $cle => $valeur)`. Omniprésente (afficher des listes, traiter des résultats).
  • `break` sort de la boucle, `continue` passe à l'itération suivante. Attention aux BOUCLES INFINIES (condition qui ne devient jamais fausse → script bloqué).
  • Syntaxe alternative `foreach (...): ... endforeach;` privilégiée dans les TEMPLATES HTML. Les boucles traitent des ENSEMBLES de données — au cœur des applications web.

Questions fréquentes

Quand utiliser for, while ou foreach — comment choisir la bonne boucle ?

Chaque boucle a son cas d'usage naturel, et choisir la bonne rend le code plus clair et adapté — voici la grille de décision. (1) foreach — pour PARCOURIR une collection (le cas le plus fréquent en PHP). Dès que vous voulez « faire quelque chose POUR CHAQUE élément » d'un tableau (ou d'un objet itérable), foreach est le choix naturel et de loin le plus utilisé en PHP. Exemples : afficher chaque produit d'une liste, traiter chaque ligne d'un résultat de base de données, parcourir chaque champ d'un formulaire. foreach gère automatiquement l'itération (vous n'avez pas à gérer d'index ni de condition d'arrêt) — c'est plus SIMPLE et plus SÛR que d'itérer un tableau avec un for et un index. Deux formes : foreach ($tab as $valeur) (si vous n'avez besoin que des valeurs) et foreach ($tab as $cle => $valeur) (si vous avez aussi besoin des clés, notamment pour les tableaux associatifs). En pratique, dès que vous manipulez un tableau (ce qui est CONSTANT en PHP web : résultats de requêtes, listes, données), foreach est votre outil. (2) for — quand vous avez besoin d'un COMPTEUR ou d'un nombre de répétitions PRÉCIS. Utilisez for quand : vous connaissez le nombre exact de répétitions (for ($i = 0; $i < 10; $i++) — 10 fois), vous avez besoin de l'INDEX numérique pour un calcul, ou vous itérez avec un pas particulier (de 2 en 2, à rebours…). Le for vous donne le contrôle explicite du compteur (initialisation, condition, incrément). Mais pour SIMPLEMENT parcourir un tableau, foreach est préférable (plus simple, moins d'erreurs d'index). Réservez for aux cas où le compteur/index est réellement utile. (3) while — quand vous répétez TANT QU'une condition est vraie, sans connaître le nombre de répétitions à l'avance. Utilisez while quand la fin dépend d'une CONDITION qui évoluera, pas d'un compte fixe. Exemples : lire des données jusqu'à la fin d'un fichier/flux, répéter tant qu'une condition métier est vraie, traiter tant qu'il reste des éléments à traiter (condition dynamique). while (condition) { ... } continue tant que la condition est vraie. Point de vigilance : assurez-vous que la condition FINIRA par être fausse (sinon boucle infinie) — quelque chose dans le corps de la boucle doit faire évoluer la condition. (4) do...while — comme while, mais exécute AU MOINS UNE FOIS. Cas plus rare : quand vous voulez exécuter le corps de la boucle au moins une fois AVANT de tester la condition (le test est à la fin). Utile quand le premier passage est toujours nécessaire (par exemple, demander une saisie puis vérifier, en boucle jusqu'à une saisie valide). La grille de décision : (1) Parcourir un TABLEAU / une collection → foreach (le cas dominant en PHP). (2) Nombre de répétitions PRÉCIS ou besoin d'un COMPTEUR/index → for. (3) Répéter TANT QU'une condition (nombre inconnu, condition dynamique) → while. (4) Idem mais exécuter au moins une fois → do...while. Points de vigilance transversaux : (1) Boucles infinies : dans un for ou while, assurez-vous que la condition deviendra fausse (compteur incrémenté, condition qui évolue) — une boucle infinie bloque le script (et le serveur). C'est un bug classique (oublier l'incrément, condition mal écrite). (2) Préférer foreach pour les tableaux : évitez d'itérer un tableau avec for et un index quand foreach suffit (plus simple, moins d'erreurs). (3) break/continue pour affiner : sortir tôt (break, dès qu'on a trouvé) ou ignorer des éléments (continue) dans n'importe quelle boucle. En résumé : foreach pour parcourir une collection (le cas le plus fréquent, à privilégier pour les tableaux) ; for pour un nombre précis de répétitions ou un besoin de compteur/index ; while pour répéter selon une condition dynamique (nombre inconnu) ; do...while pour exécuter au moins une fois. Choisissez selon que vous parcourez une collection (foreach), comptez (for), ou attendez une condition (while). En PHP web, foreach domine (on manipule constamment des tableaux) — c'est la boucle à maîtriser en priorité. Le bon choix rend le code plus clair et évite les erreurs (notamment de gestion d'index et de boucles infinies).

Pourquoi foreach est-il si central en PHP, et comment l'utiliser efficacement ?

foreach est central en PHP parce que le développement web consiste largement à MANIPULER DES COLLECTIONS de données (tableaux), et foreach est l'outil idéal pour cela — le maîtriser est essentiel car vous l'utiliserez constamment. Pourquoi foreach est si central : (1) PHP web = manipulation de tableaux. Dans une application web PHP, vous manipulez en permanence des TABLEAUX : les résultats d'une requête de base de données (une liste de produits, d'utilisateurs, de commandes — chacun un tableau), les données envoyées par un formulaire ($_POST est un tableau), des listes de configuration, des collections d'objets. Traiter ces données signifie presque toujours « faire quelque chose pour chaque élément » — exactement ce que fait foreach. (2) Simplicité et sûreté. foreach gère automatiquement le parcours : il prend chaque élément à tour de rôle, sans que vous ayez à gérer un index, une condition d'arrêt, ou l'incrémentation (contrairement à un for). Moins de code, moins d'erreurs (pas de risque d'index hors limites, de décalage, de boucle infinie). C'est l'outil le plus simple et le plus sûr pour parcourir une collection. (3) Lisibilité. foreach ($produits as $produit) se lit clairement : « pour chaque produit dans la liste des produits ». L'intention est évidente. Comment l'utiliser efficacement : (1) Choisir la bonne forme. (a) foreach ($tab as $valeur) : quand vous n'avez besoin que des VALEURS (parcourir une liste et traiter chaque élément). (b) foreach ($tab as $cle => $valeur) : quand vous avez besoin des CLÉS aussi — indispensable pour les tableaux ASSOCIATIFS (où les clés portent du sens : foreach ($config as $option => $valeur)) ou quand l'index compte. (2) Cas typiques d'usage : (a) AFFICHER une liste en HTML : parcourir les résultats et générer le HTML de chacun (une ligne de tableau, une carte de produit) — omniprésent dans les vues. (b) TRAITER des données : calculer une somme, filtrer, transformer chaque élément. (c) PARCOURIR les données d'un formulaire ou une structure de données. (3) Dans les TEMPLATES (HTML), utilisez la syntaxe alternative : <?php foreach ($produits as $produit): ?> ... HTML ... <?php endforeach; ?> — plus lisible mêlée au HTML que les accolades. (4) ÉCHAPPER les données affichées (sécurité) : quand vous affichez des valeurs venant de la base ou de l'utilisateur dans une boucle, utilisez htmlspecialchars() pour éviter le XSS (section 3-4). Ne jamais afficher brutalement des données non fiables, même dans une boucle. (5) Attention à la MODIFICATION pendant l'itération : modifier le tableau qu'on parcourt peut causer des comportements inattendus. Pour modifier les valeurs, on peut utiliser une référence (foreach ($tab as &$valeur)) — mais avec PRÉCAUTION (un piège classique : la référence persiste après la boucle et peut corrompre le dernier élément si on réutilise la variable ; il faut la libérer avec unset($valeur) après). Pour la plupart des cas, préférez construire un NOUVEAU tableau (transformation) plutôt que modifier en place. (6) Combinez avec break/continue : break pour sortir dès qu'on a trouvé/atteint un but, continue pour ignorer certains éléments (sauter ceux qui ne remplissent pas une condition). (7) Pour des transformations, connaissez aussi les fonctions de tableau (section 1-5) : array_map (transformer chaque élément), array_filter (filtrer), array_reduce (agréger) offrent une alternative « fonctionnelle » à foreach pour certains traitements — parfois plus expressive (mais foreach reste très utilisé et parfaitement valable). En résumé : foreach est central en PHP parce que le web consiste à manipuler des collections (tableaux : résultats de base, données de formulaire, listes), et foreach est l'outil idéal (simple, sûr, lisible) pour « faire quelque chose pour chaque élément ». Pour l'utiliser efficacement : choisissez la bonne forme (valeur seule, ou clé => valeur pour les associatifs), utilisez la syntaxe alternative dans les templates, échappez les données affichées (sécurité), attention à la modification pendant l'itération (référence avec précaution, ou construire un nouveau tableau), et combinez avec break/continue. foreach est probablement la boucle que vous écrirez le plus en PHP — le maîtriser (avec ses bonnes pratiques) est essentiel pour traiter et afficher les données, au cœur de toute application web.

Autres ressources