Les Boucles
Présentation
Les boucles permettent d'exécuter un bloc de code de manière répétée en fonction d'une condition ou d'un ensemble de conditions spécifiées. Elles sont essentielles pour automatiser des tâches répétitives et pour parcourir des collections de données, comme les tableaux.
Voici les 4 principaux types de boucles :
- La boucle "while" (tant que) : La boucle while vous permet de répéter un bloc de code tant qu'une condition spécifiée reste vraie. Elle est utile lorsque le nombre d'itérations dépend de la condition et n'est pas connu à l'avance.
- La boucle "do...while" (faire...tant que) :La boucle do...while est similaire à la boucle while, mais elle garantit qu'au moins une itération du bloc de code sera exécutée avant que la condition soit évaluée. Cela la rend appropriée pour des situations où vous souhaitez que le bloc de code s'exécute au moins une fois, quelle que soit la condition.
- La boucle "for" (pour) : La boucle for est un outil puissant pour répéter un bloc de code un nombre spécifique de fois. Elle est idéale lorsque vous connaissez à l'avance le nombre d'itérations nécessaire.
- La boucle "foreach" (pour chaque) : La boucle foreach est conçue pour parcourir facilement tous les éléments d'un tableau. Elle permet d'accéder directement aux valeurs (et éventuellement aux clés) sans avoir à gérer manuellement les index.
Soyez vigilant lors de l'utilisation de boucles en programmation, car une mauvaise gestion peut entraîner des boucles infinies. Les boucles infinies sont des situations où une boucle continue d'exécuter son bloc de code sans jamais s'arrêter, ce qui peut geler ou ralentir votre programme et causer des problèmes. Si vous tombez dans une boucle infinie lors de vos tests dans le terminal pour pouvez interrompre le script en appuyant sur les touches Ctrl + C ou fermer la fenêtre du terminal.
La Boucle while
La boucle while permet d'exécuter un bloc de code tant qu'une condition spécifiée reste vraie. Voici comment fonctionne une boucle while avec un exemple :
<?php
// Initialisation du compteur à 1.
$compteur = 1;
// Tant que la valeur du compteur est inférieure à 6 exécute les instructions situées dans le bloc entre accolades :
while ($compteur < 6) {
// Affiche la valeur du compteur.
echo "\$compteur vaut: $compteur" . PHP_EOL;
// Incrémentation du compteur.
$compteur++; // équivalent à $compteur = $compteur + 1;
}
/*
Affiche :
$compteur vaut: 1
$compteur vaut: 2
$compteur vaut: 3
$compteur vaut: 4
$compteur vaut: 5
*/
?>
Nous venons de découvrir un nouvelle opérateur, l'opérateur d'incrémentation ++. Cet opérateur est utilisé pour augmenter la valeur d'une variable en lui ajoutant 1. Comme vous pouvez le deviner, il a également son équivalent pour la décrémentation, l'opérateur --.
Revenons à la manière dont notre boucle while fonctionne. Comme expliqué précédemment, l'objectif d'une boucle est d'éviter les répétitions tout en permettant l'exécution répétée d'une action un certain nombre de fois. Si nous avions cherché à obtenir le même résultat sans utiliser de boucle, notre code aurait ressemblé à ceci :
<?php
$compteur = 1;
echo "\$compteur vaut: $compteur" . PHP_EOL;
$compteur++;
echo "\$compteur vaut: $compteur" . PHP_EOL;
$compteur++;
echo "\$compteur vaut: $compteur" . PHP_EOL;
$compteur++;
echo "\$compteur vaut: $compteur" . PHP_EOL;
$compteur++;
echo "\$compteur vaut: $compteur" . PHP_EOL;
$compteur++;
/*
Affiche :
$compteur vaut: 1
$compteur vaut: 2
$compteur vaut: 3
$compteur vaut: 4
$compteur vaut: 5
*/
?>
La Boucle do...while
Contrairement à la boucle while, la boucle do...while garantit que le bloc de code sera exécuté au moins une fois, même si la condition de boucle est initialement fausse.
Le fonctionnement de la boucle do...while est le suivant : le bloc de code est exécuté une première fois, puis la condition est évaluée. Si la condition est vraie, le bloc de code est ré-exécuté, et cela continue tant que la condition reste vraie :
<?php
// Initialisation du compteur à 6.
$compteur = 6;
// Exécute une première fois le bloc situé après l'instruction do et ensuite, fais de même tant que la valeur du compteur est inférieure ou égale à 5 :
do {
// Afficher la valeur du compteur.
echo "\$compteur vaut: $compteur" . PHP_EOL;
// Incrémentation du compteur.
$compteur++;
} while ($compteur <= 5);
// Affiche : $compteur vaut: 6
?>
Bien que la condition n'est pas respectée dès sa première interrogation, les instructions du bloc do sont bien exécutées une première fois. Si nous avions utilisé la boucle while ça n'aurait pas été le cas.
La Boucle for
La boucle for est une structure flexible, idéale lorsque vous connaissez le nombre d'itération à l'avance. Elle se compose de trois parties : l'initialisation, la condition et l'incrémentation, qui sont spécifiées dans la déclaration de la boucle. Chacune de ces parties doit être séparée d'un point-virgule ; :
for (initialisation; condition; expression) { bloc d'instructions à exécuter si la condition retourne vrai }
<?php
// Tant que la valeur de la variable $compteur est inférieure à 6, incrémente cette variable et exécute les instructions présentes dans le bloc :
for ($compteur = 1; $compteur < 6; $compteur++)
{
// Affiche la valeur du compteur.
echo "\$compteur vaut: $compteur" . PHP_EOL;
}
/*
Affiche :
$compteur vaut: 1
$compteur vaut: 2
$compteur vaut: 3
$compteur vaut: 4
$compteur vaut: 5
*/
?>
Vous pourriez circuler au sein de tableau mais pour cela vous aurez besoin de la fonction count() qui renvoie le nombre d'élément qui y sont présent pour signaler le nombre d'itération que celle-ci doit effectuer :
<?php
$laFineEquipe = ['Claudy', 'Jean-Claude', 'Laurence'];
// Tant que la valeur de la variable $index est inférieure aux nombre d'éléments présents dans le tableau $laFineEquipe (valeur obtenue à l'aide de la fonction count()), incrémente la valeur de la variable index et exécute les instructions présentes dans le bloc :
for ($index = 0; $index < count($laFineEquipe); $index++)
{
// Affiche la valeur du compteur.
echo "{$laFineEquipe[$index]}" . PHP_EOL;
}
/*
Affiche :
Claudy
Jean-Claude
Laurence
*/
?>
Dans cet exemple, la variable $index sert d'indicateur de position à l'intérieur du tableau. La fonction count($laFineEquipe) renvoie le nombre d'éléments contenus dans $laFineEquipe, ce qui permet de fixer une limite claire à la boucle et d'éviter tout dépassement d'index.
La Boucle foreach
La boucle foreach est souvent la manière la plus simple et la plus lisible pour parcourir un tableau. Contrairement aux boucles for, il n'est pas nécessaire de gérer manuellement un index ou la limite du tableau.
À chaque itération, foreach place dans une variable la valeur de l'élément courant. Cette variable porte le nom que vous choisissez et ne modifie pas le tableau original. C'est donc une structure idéale pour lire des données sans risque d'erreur liée aux index.
Parcourir un tableau indexé (sans utiliser les index)
Un tableau indexé utilise des clés numériques générées automatiquement comme 0, 1, 2, etc. Dans de nombreuses situations, seul le contenu nous intéresse, pas la position dans le tableau.
foreach (tableau as valeurCourante) { ... }
Dans l'exemple suivant, on parcourt un tableau de prénoms en lisant chaque valeur successivement, sans tenir compte des index.
<?php
$membres = ['Claudy', 'Jean-Claude', 'Laurence'];
// À chaque tour, $prenom contient la valeur courante du tableau.
foreach ($membres as $prenom)
{
// Affiche le prénom correspondant à l'élément courant suivi d'un saut de ligne
echo $prenom . PHP_EOL;
}
/*
Affiche :
Claudy
Jean-Claude
Laurence
*/
?>
Cette forme est la plus lisible lorsque l'on souhaite parcourir un tableau pour afficher, analyser ou traiter des valeurs une par une. Pas besoin de manipuler les index et aucun risque de dépasser la taille du tableau, contrairement à for.
Parcourir un tableau associatif (sans utiliser les clés)
Dans un tableau associatif, les clés sont des chaînes. La forme simple de foreach reste pertinente si les clés ne sont pas nécessaires.
<?php
$prix = [
'clavier' => 49.99,
'souris' => 19.5,
'ecran' => 149
];
// On ignore volontairement les clés car seule la valeur nous intéresse.
foreach ($prix as $valeur)
{
// Affiche le prix correspondant à l'élément courant suivi d'un saut de ligne
echo $valeur . PHP_EOL;
}
/*
Affiche :
49.99
19.5
149
*/
?>
Cette forme est très utile lorsqu'un script doit simplement parcourir une liste de valeurs sans se soucier du nom associé.
Accéder à la clé dans un tableau indexé
Si vous avez besoin de connaître la position de chaque élément par exemple pour afficher des numéros de ligne vous pouvez récupérer à la fois l'index et la valeur.
foreach (tableau as cleCourante => valeurCourante) { ... }
Dans l'exemple suivant, on parcourt le tableau des membres et à chaque itération on affiche l'index suivi de la valeur correspondante.
<?php
$membres = ['Claudy', 'Jean-Luc', 'Laurence'];
// $index contient : 0, 1, 2
// $prenom contient la valeur à cette position.
foreach ($membres as $index => $prenom)
{
// À chaque itération, $index représente la position de l'élément
// et $prenom contient la valeur associée à cette position.
// On combine les deux pour afficher une ligne lisible.
echo "Index $index : $prenom" . PHP_EOL;
}
/*
Affiche :
Index 0 : Claudy
Index 1 : Jean-Luc
Index 2 : Laurence
*/
?>
Cette écriture reste plus simple qu'une boucle for car PHP gère lui-même la progression dans le tableau et la récupération de l'index exact.
Accéder à la clé dans un tableau associatif
Dans un tableau associatif, la clé décrit ce que représente la valeur. Récupérer la clé devient utile lorsque le traitement dépend d'une information qui n'est pas dans la valeur elle-même, par exemple pour afficher un libellé, identifier un élément ou préparer un résumé lisible.
Dans l'exemple suivant, on parcourt une liste de produits. À chaque itération, on récupère le nom du produit (la clé) et son prix (la valeur) pour afficher une ligne lisible.
<?php
$prix = [
'clavier' => 49.99,
'souris' => 19.5,
'ecran' => 149
];
// $nomProduit correspond à la clé (ex. 'clavier')
// $montant correspond à la valeur (ex. 49.99)
foreach ($prix as $nomProduit => $montant)
{
// À chaque tour, on utilise la clé pour identifier le produit
// et la valeur pour afficher son prix.
echo "Produit : $nomProduit, prix : $montant €" . PHP_EOL;
}
/*
Affiche :
Produit : clavier, prix : 49.99 €
Produit : souris, prix : 19.5 €
Produit : ecran, prix : 149 €
*/
?>
Cette approche est très utilisée côté backend par exemple pour afficher des listes d'articles, des utilisateurs, des rôles, des paramètres configurables car elle permet de comprendre immédiatement ce qui est traité.
Retenez que foreach est adapté dès que l'on veut parcourir un tableau sans manipuler manuellement les index. C'est la boucle la plus pratique pour lire des données, analyser leur contenu, construire un résumé ou générer des messages à partir d'une collection.
Parcourir une chaîne de caractères en PHP
On doit parfois analyser une chaîne caractère par caractère pour compter certaines lettres, filtrer des symboles, valider un mot de passe ou préparer une partie d'un texte avant de l'afficher.
Les boucles permettent de parcourir une chaîne position par position, mais il faut garder en tête que PHP manipule avant tout des octets. Une chaîne n'est donc pas traitée comme une suite de caractères humains mais comme une suite de valeurs brutes. Cette distinction devient importante dès que le texte contient des accents, des symboles complexes ou des emojis.
Les chaînes sont des suites d'octets
En PHP, une chaîne est stockée comme une suite d'octets. Chaque octet possède une valeur comprise entre 0 et 255. Dans la table ASCII d'origine, chaque valeur entre 0 et 127 correspond à un caractère précis. Par exemple, la valeur décimale 97 représente la lettre a et la valeur 122 représente la lettre z.
Cette table inclut les lettres non accentuées, les chiffres, la ponctuation ainsi que quelques symboles de contrôle. Les caractères accentués n'y figurent pas, ce qui signifie que l'ASCII ne prévoit aucun signe particulier propre aux langues modernes. Tant que l'on reste dans cet ensemble, un octet correspond toujours à un caractère complet.
Parcourir une chaîne sans accents
Les fonctions historiques comme strlen comptent les octets présents dans une chaîne. Avec un texte ASCII pur, la longueur mesurée correspond donc exactement au nombre de caractères visibles, ce qui ne pose aucun problème.
<?php
// Chaîne ASCII simple.
$mot = "formater";
// La fonction prédéfinie "strlen()" renvoie le nombre d'octets présents dans une chaîne.
// Ici, tous les caractères sont ASCII, donc un octet = un caractère.
$longueur = strlen($mot);
// Itérer autant de fois qu'il y a d'octets dans la chaîne "formater".
for ($i = 0; $i < $longueur; $i++)
{
// Chaque position correspond directement à un caractère complet.
// Si $i vaut 0, alors $mot[0] vaut "f".
// Si $i vaut 1, alors $mot[1] vaut "o".
// Si $i vaut 2, alors $mot[2] vaut "r".
// ...
$caractere = $mot[$i];
// Afficher la valeur courante de $i
// ainsi que le caractère extrait à cette position.
echo "Position $i : $caractere\n";
}
Parcourir une chaîne avec accents
L'encodage UTF-8 a été conçu pour représenter toutes les langues du monde au moyen d'un système à longueur variable. Certains caractères utilisent toujours un seul octet tandis que d'autres en utilisent plusieurs.
- 1 octet pour les caractères ASCII
- 2 octets pour de nombreuses lettres accentuées
- 3 octets pour beaucoup de symboles internationaux
- 4 octets pour les emojis ou certains idéogrammes
Comme PHP manipule les octets par défaut, strlen renvoie la taille en octets et non le nombre réel de caractères visibles. Une lettre accentuée comme é occupe souvent deux octets ce qui signifie qu'elle est comptée comme deux unités alors qu'elle représente un seul caractère humain. Accéder à une position avec $texte[$i] peut donc renvoyer un fragment partiel d'un caractère multioctet ce qui produit un symbole incohérent ou un affichage illisible.
Pour manipuler correctement les caractères en UTF-8, PHP propose l'extension mbstring. Le préfixe mb_ signifie multi-byte ce qui se traduit par multioctet en français. Ces fonctions travaillent sur des caractères complets plutôt que sur les octets qui les composent.
Une fonction comme mb_strlen mesure ainsi la longueur réelle d'une chaîne UTF-8 même lorsqu'elle contient des accents ou des symboles complexes. Cette mesure reste fiable, mais elle ne suffit pas pour parcourir une chaîne car l'accès direct avec $texte[$i] continue de lire les octets séparément. Le mélange des deux approches conduit alors à découper les caractères multioctets en fragments incohérents ou non affichables.
<?php
// Chaîne UTF-8 simple contenant un caractère accentué.
$mot = "café";
// "strlen()" lit la chaîne octet par octet.
// Le caractère "é" occupe plusieurs octets en UTF-8.
$nbrOctets = strlen($mot);
// "mb_strlen()" lit la chaîne en tant que suite de caractères multioctets.
// Le "é" est donc compté comme un seul caractère.
$nbrCaracteres = mb_strlen($mot, "UTF-8");
// strlen renvoie 5 car la chaîne contient 5 octets.
// "c", "a", "f" et les deux octets qui composent "é".
echo $nbrOctets; // Affiche 5
// mb_strlen renvoie 4 car la chaîne contient réellement 4 caractères visibles.
echo $nbrCaracteres; // Affiche 4
La différence entre les deux résultats illustre parfaitement le fonctionnement interne d'une chaîne UTF-8. La fonction strlen compte les octets et non les caractères ce qui double la taille des lettres accentuées. À l'inverse, mb_strlen interprète correctement l'encodage et renvoie la longueur réelle du texte tel qu'il apparaît à l'utilisateur.
Une boucle basée sur mb_strlen utilise donc un compte correct mais un accès incorrect. Le parcours mélange ainsi deux logiques différentes ce qui entraîne l'extraction partielle des caractères multioctets. Un caractère comme é est alors découpé en morceaux ce qui mène à un affichage incohérent ou illisible.
Pour parcourir une chaîne UTF-8 de manière fiable, il faut combiner deux fonctions mb_strlen pour obtenir le nombre de caractères et mb_substr pour extraire un caractère complet à chaque étape.
La fonction mb_substr reçoit la chaîne à analyser ainsi qu'une position de départ et une longueur exprimées en nombre de caractères et non en octets. L'appel mb_substr($texte, $i, 1) extrait donc exactement un caractère complet à la position souhaitée même lorsqu'il est représenté par plusieurs octets en mémoire. Cette approche garantit que chaque itération récupère un caractère entier et évite les découpages incohérents que l'on observe avec l'accès direct $texte[$i].
<?php
$mot = "café";
// "mb_strlen()" compte les caractères réels et non les octets.
// L'encodage "UTF-8" est indiqué pour garantir une interprétation correcte.
$longueur = mb_strlen($mot, "UTF-8");
// On parcourt maintenant la chaîne caractère par caractère.
// L'accès direct "$mot[$i]" serait incorrect car il lit les octets séparément.
for ($i = 0; $i < $longueur; $i++)
{
// "mb_substr()" extrait un caractère complet même s'il occupe plusieurs octets.
// Cette approche évite les découpages incohérents observés avec "$mot[$i]".
$caractere = mb_substr($mot, $i, 1);
// Affichage de chaque caractère repéré dans la chaîne.
echo "Caractère $i : $caractere\n";
}
Configurer correctement les fonctions multioctets
Les fonctions préfixées par mb_ travaillent sur des caractères complets et non sur les octets individuels qui les composent. Elles doivent donc connaître l'encodage utilisé pour interpréter les chaînes de manière fiable. Il est recommandé de préciser l'encodage UTF-8 afin d'éviter tout comportement inattendu lié aux paramètres internes de PHP ou à une configuration différente sur un autre serveur.
L'appel mb_internal_encoding("UTF-8") fixe l'encodage par défaut pour toutes les fonctions multioctets du script. Cette pratique évite de répéter l'encodage dans chaque appel à mb_strlen, mb_substr ou toute autre fonction multioctet. Elle assure également une cohérence sur l'ensemble du fichier ce qui facilite la lecture du code et limite les erreurs de manipulation.
<?php
// On fixe l'encodage interne à UTF-8 pour toutes les fonctions multioctets.
// Cette configuration évite de répéter "UTF-8" dans chaque appel
// et garantit une interprétation cohérente des caractères dans tout le script.
mb_internal_encoding("UTF-8");
$mot = "café";
// L'encodage n'a plus besoin d'être précisé ici.
// "mb_strlen()" utilise déjà l'encodage défini au début du script,
// ce qui simplifie l'appel et rend le code plus lisible.
$longueur = mb_strlen($mot);
for ($i = 0; $i < $longueur; $i++)
{
$caractere = mb_substr($mot, $i, 1);
echo "Caractère $i : $caractere\n";
}
Notez qu'il est très important de configurer l'encodage interne avant toute utilisation d'une fonction multioctet. L'instruction mb_internal_encoding("UTF-8") doit donc être placée le plus près possible de l'entrée du script. Cette position garantit que toutes les fonctions mb_ travailleront avec le bon encodage et que leurs résultats resteront cohérents.
Les boucles imbriquées
Une boucle imbriquée est une boucle placée à l'intérieur d'une autre boucle. Ce schéma apparaît dès que les données sont organisées sur plusieurs niveaux. Par exemple un tableau qui contient d'autres tableaux, des catégories qui contiennent des éléments, des commandes qui contiennent des lignes.
La boucle externe parcourt le premier niveau de la structure et, pour chaque élément rencontré, la boucle interne parcourt le niveau suivant. Il faut bien garder en tête ce principe pour chaque élément du niveau 1, on traite tous les éléments du niveau 2.
Parcourir un tableau à deux dimensions avec des boucles for
Prenons un tableau qui contient plusieurs séries de nombres. Chaque série est elle-même un tableau et peut contenir un nombre de valeurs différent. L'objectif consiste à afficher l'index de la série puis chacune des valeurs qu'elle contient.
<?php
// Tableau parent avec trois sous-tableaux de tailles différentes.
$serieDeNombres = [
[1, 2],
[2, 3, 4, 5],
[5, 6, 7],
];
// Parcourir tous les sous-tableaux du tableau parent.
for ($indexParent = 0; $indexParent < count($serieDeNombres); $indexParent++)
{
// Afficher l'index du sous-tableau courant.
echo "Index du tableau parent : $indexParent" . PHP_EOL;
// Récupérer le sous-tableau à cet index pour clarifier la lecture.
$sousTableau = $serieDeNombres[$indexParent];
// Parcourir tous les éléments du sous-tableau courant.
for ($indexEnfant = 0; $indexEnfant < count($sousTableau); $indexEnfant++)
{
// Accéder à la valeur située au niveau enfant.
$valeur = $sousTableau[$indexEnfant];
echo " Valeur du sous-tableau : $valeur" . PHP_EOL;
}
}
/*
Affiche :
Index du tableau parent : 0
Valeur du sous-tableau : 1
Valeur du sous-tableau : 2
Index du tableau parent : 1
Valeur du sous-tableau : 2
Valeur du sous-tableau : 3
Valeur du sous-tableau : 4
Valeur du sous-tableau : 5
Index du tableau parent : 2
Valeur du sous-tableau : 5
Valeur du sous-tableau : 6
Valeur du sous-tableau : 7
*/
?>
La première boucle se contente de choisir un sous-tableau dans le tableau parent et de fournir son index. La seconde boucle parcourt ce sous-tableau et donne accès à chacune de ses valeurs. Cette structure se retrouve souvent dans des traitements de tableaux à deux dimensions ou dans des données structurées en lignes et colonnes.
Ajouter une condition dans la boucle interne
Dans un cas réel, la boucle interne ne se limite pas à afficher des valeurs. Elle sert souvent à filtrer, calculer un total ou préparer des données avant un traitement plus lourd. On peut par exemple ne retenir que les valeurs paires dans chaque série.
<?php
// Tableau parent avec trois sous-tableaux de tailles différentes.
$serieDeNombres = [
[1, 2],
[2, 3, 4, 5],
[5, 6, 7],
];
for ($indexParent = 0; $indexParent < count($serieDeNombres); $indexParent++)
{
echo "Index du tableau parent : $indexParent" . PHP_EOL;
$sousTableau = $serieDeNombres[$indexParent];
for ($indexEnfant = 0; $indexEnfant < count($sousTableau); $indexEnfant++)
{
$valeur = $sousTableau[$indexEnfant];
// L'opérateur modulo "%" renvoie le reste de la division.
// Si $valeur % 2 vaut 0, la valeur est paire.
if ($valeur % 2 === 0)
{
echo " Valeur paire : $valeur" . PHP_EOL;
}
}
}
/*
Affiche :
Index du tableau parent : 0
Valeur paire : 2
Index du tableau parent : 1
Valeur paire : 2
Valeur paire : 4
Index du tableau parent : 2
Valeur paire : 6
*/
?>
La logique reste la même la boucle externe choisit un sous-ensemble de données la boucle interne parcourt les valeurs individuelles et la structure conditionnelle au sein de la boucle interne décide si une valeur donnée doit être traitée ou ignorée. Ce schéma se retrouve par exemple lors de l'analyse de statistiques du nettoyage de données avant insertion en base ou du calcul d'indicateurs sur des groupes de valeurs.
Nature des boucles imbriquées
Les boucles imbriquées ne sont pas limitées à une seule forme de boucle. Elles fonctionnent avec toutes les structures vues dans ce chapitre : while, do...while, for et foreach. Une boucle de nature différente peut tout à fait être placée à l'intérieur d'une autre. Cette souplesse permet de s'adapter aux formats variés de données rencontrés en backend, où un niveau peut représenter des éléments (commandes, utilisateurs, catégories) et un autre les détails associés (lignes, droits, produits).
Dans certaines situations, il est utile de proposer une liste d'options à l'utilisateur, puis de vérifier si la clé qu'il saisit correspond réellement à un élément du tableau disponible. C'est un cas fréquent en ligne de commande, par exemple pour choisir un produit, un utilisateur ou un mode de configuration. Une boucle do...while permet de répéter la saisie tant qu'elle est incorrecte, tandis qu'une boucle foreach sert à afficher les choix possibles. L'exemple introduit aussi la fonction array_key_exists(), utilisée pour vérifier qu'une clé existe réellement dans un tableau associatif.
<?php
// Liste des produits existants dans le système.
// Il s'agit d'un tableau associatif : chaque clé (ex.: 'P100')
// représente l'identifiant d'un produit.
$produits = [
'P100' => 'Clavier mécanique',
'P200' => 'Souris ergonomique',
'P300' => 'Écran 27 pouces',
];
$choix = null;
do
{
echo "Produits disponibles :" . PHP_EOL;
// À chaque tentative, on réaffiche la liste complète des produits.
// La clé correspond à l'identifiant, la valeur correspond au nom du produit.
foreach ($produits as $idProduit => $nomProduit)
{
echo " - $idProduit : $nomProduit" . PHP_EOL;
}
// Ajouter un retour à la ligne dans le terminal.
echo PHP_EOL;
// Demander à l'utilisateur de sélectionner un produit à partir de son id (P100, P200 ou P300).
$choix = readline("Entrez un identifiant de produit : ");
// La fonction array_key_exists() permet de vérifier si une clé existe dans un tableau associatif.
// array_key_exists($cle, $tableau) renvoie true si $cle est une clé présente dans $tableau, sinon false.
//
// Vérifie si l'identifiant saisi par l'utilisateur existe parmi les clés du tableau $produits.
$estIdentifiantValide = array_key_exists($choix, $produits);
// Si l'identifiant n'existe pas afficher un message à l'utilisatuer pour l'en informer.
if (!$estIdentifiantValide)
{
echo "Identifiant inconnu, veuillez réessayer." . PHP_EOL . PHP_EOL;
}
} while (!$estIdentifiantValide);
// Si on arrive ici, c'est que la clé existe dans le tableau.
// On peut donc accéder en toute sécurité au nom du produit associé.
echo "Vous avez sélectionné : {$produits[$choix]}" . PHP_EOL;
?>
Cet enchaînement montre comment une boucle do...while peut fonctionner avec une boucle foreach dans un même traitement. La première valide une saisie utilisateur de manière répétée, la seconde affiche les options disponibles. La fonction array_key_exists() garantit que la clé fournie existe bien avant d'utiliser sa valeur, ce qui évite erreurs et accès non définis. Cette structure se retrouve souvent dans les scripts backend qui valident une entrée avant de poursuivre un traitement plus avancé.
Pour en savoir plus concernant la fonction prédéfinie array_key_exists(), vous pouvez consulter la documentation officielle sur php.net.
Les instructions break et continue
Dans une boucle, on utilise souvent des structures conditionnelles pour décider quelles instructions exécuter à chaque tour. On place alors des if autour de certaines parties du code pour ne traiter que des cas bien précis. Quand ces cas se multiplient, les conditions finissent par s'imbriquer ou par s'enchaîner les unes après les autres, ce qui rend le bloc plus difficile à lire et à maintenir.
Les instructions break et continue offrent une autre manière de contrôler le déroulement d'une boucle depuis l'intérieur de son bloc. Elles ne remplacent pas les structures conditionnelles, elles les complètent. break sert lorsque l'on décide qu'il n'est plus nécessaire de poursuivre la boucle dès qu'une condition est remplie. continue sert lorsque l'on souhaite ignorer le reste des instructions du bloc pour un cas précis et passer directement à l'itération suivante. Utilisées avec des if simples, elles permettent de garder des blocs plus linéaires et d'éviter les enchaînements de if...else trop profonds.
Dans le cas de boucles imbriquées, break et continue peuvent aussi agir sur les niveaux supérieurs de la structure de boucles. Par défaut, ils contrôlent uniquement la boucle dans laquelle ils sont appelés, mais on peut leur fournir un nombre pour viser une boucle parente. Par exemple, break 2 interrompt la boucle courante et sa boucle parente, tandis que continue 2 demande de passer directement à l'itération suivante de la boucle parente. Une structure conditionnelle classique ne peut pas, à elle seule, modifier le déroulement des niveaux supérieurs de cette manière.
Arrêter une boucle avec break
L'instruction break met fin immédiatement à la boucle courante. Le programme passe à l'instruction située juste après la boucle. Cela évite de parcourir inutilement le reste des données lorsqu'on a déjà trouvé ce que l'on cherchait.
Exemple. Recherche d'un utilisateur dans une liste en mémoire avant un traitement plus lourd côté serveur.
<?php
// Identifiant de l'utilisateur que l'on souhaite retrouver.
$utilisateurRecherche = 'u456';
// Liste des utilisateurs actuellement connectés au système.
$utilisateursConnectes = [
'u123',
'u234',
'u456',
'u789',
];
// Variable "drapeau" (booléenne) qui indiquera si l'utilisateur a été trouvé ou non.
$trouve = false;
// Parcourir la liste de tous les utilisateurs connectés.
foreach ($utilisateursConnectes as $idUtilisateur)
{
echo "Vérification de l'utilisateur $idUtilisateur" . PHP_EOL;
// Vérifier si l'utilisateur courant est celui recherché.
if ($idUtilisateur === $utilisateurRecherche)
{
echo "Utilisateur $idUtilisateur trouvé, préparation du chargement de son tableau de bord." . PHP_EOL;
// On mémorise le fait qu'un utilisateur correspondant a été trouvé.
$trouve = true;
// Inutile de continuer à parcourir le reste du tableau :
// dès que l'utilisateur recherché est trouvé, on interrompt la boucle.
// Sans ce "break", la boucle continuerait à vérifier les autres identifiants.
break;
}
}
// Après la boucle, on vérifie si un utilisateur correspondant a été trouvé.
if ($trouve === false)
{
echo "Utilisateur non trouvé dans la liste des utilisateurs connectés." . PHP_EOL;
}
?>
Sans break, la boucle continuerait à vérifier tous les utilisateurs même après la découverte de u456. Dans un vrai projet backend, une telle optimisation devient importante lorsque les tableaux contiennent de nombreuses valeurs ou proviennent de requêtes coûteuses.
Passer à l'itération suivante avec continue
L'instruction continue permet de sauter directement à l'itération suivante de la boucle courante. Tout le code situé après continue dans le bloc n'est pas exécuté pour l'itération en cours.
Cela est utile lorsqu'une partie des données ne doit pas être traitée par la suite du bloc, comme lorsque seuls certains types de messages de journal demandent une action. Dans l'exemple suivant, les messages d'information sont ignorés et seuls les autres messages sont réellement traités.
<?php
$journal = [
'INFO Démarrage du service',
'DEBUG Variable X = 42',
'WARNING Espace disque faible',
'INFO Connexion utilisateur',
'ERROR Échec de connexion à la base de données',
];
// Parcourir chaque message du journal.
foreach ($journal as $message)
{
// La fonction str_starts_with($message, 'INFO') vérifie si la chaîne $message
// commence par le texte "INFO". Elle renvoie true si c'est le cas, false sinon.
// Les messages "INFO" ne demandent aucune action.
// "continue" saute le reste du bloc et passe directement
// à l'itération suivante de la boucle.
if (str_starts_with($message, 'INFO'))
{
continue;
}
// Tous les autres messages atteignent cette partie du code,
// où ils peuvent être analysés ou consignés.
echo "Traitement du message : $message" . PHP_EOL;
}
?>
Dans cet exemple, les messages commençant par INFO ne passent jamais dans la partie traitement du bloc. Ici, il n'y a qu'un simple echo pour la démonstration, mais dans une situation réelle, cette zone pourrait rassembler plusieurs étapes de traitement. Dans ce cas, utiliser continue permet de filtrer rapidement les messages qui ne doivent pas être traités et de garder le bloc principal clair et linéaire, sans devoir englober tout le traitement dans un grand if.
Si vous désirez en savoir plus concernant la fonction prédéfinie str_starts_with(), consultez la documentation officielle sur php.net.
Utilisation dans des boucles imbriquées
Dans un backend, les données sont souvent organisées sur plusieurs niveaux comme des jours contenant des messages de journal ou des commandes contenant des lignes. Les boucles imbriquées sont donc fréquentes.
Par défaut, break et continue agissent uniquement sur la boucle dont ils dépendent directement c'est-à-dire la boucle qui les englobe immédiatement. Même s'ils sont placés dans plusieurs niveaux d'imbrication, ils n'affectent jamais les boucles parentes à moins qu'un nombre leur soit fourni comme break n ou continue n.
Quitter plusieurs niveaux avec break n
Exemple tiré d'un traitement de journaux techniques. On parcourt des jours puis, pour chaque jour, une liste de messages. Dès qu'un message critique apparaît, il n'est plus utile de lire les autres messages ni d'analyser les jours suivants. break 2 permet d'interrompre immédiatement les deux niveaux.
<?php
$journalParJour = [
'jour1' => ['INFO OK', 'WARNING Latence réseau'],
'jour2' => ['INFO OK', 'CRITICAL Panne serveur', 'DEBUG Trace'],
'jour3' => ['INFO OK', 'INFO OK'],
];
// Parcourir les jours.
foreach ($journalParJour as $jour => $messages)
{
// Parcourir les messages lié au jour courant.
foreach ($messages as $message)
{
// Détection d'un message critique débutant par 'CRITICAL'.
if (str_starts_with($message, 'CRITICAL'))
{
echo "Alerte critique détectée au $jour" . PHP_EOL;
// Quitter les deux niveaux de boucles :
// Boucle actuelle : les messages.
// Boucle parent : les jours.
break 2;
}
}
}
echo "Fin de l'analyse du journal" . PHP_EOL;
?>
Ici, break 2 arrête la boucle interne qui parcourait les messages du jour courant et la boucle externe qui parcourait les jours.
Ignorer des données sur plusieurs niveaux avec continue n
On peut utiliser continue n pour demander à plusieurs niveaux de boucles de passer immédiatement à leur prochaine itération. Ce comportement est utile lorsque certains cas rendent inutile l'analyse du reste d'un élément complet comme une commande entière.
Dans l'exemple suivant, on parcourt une liste de commandes, chacune composée de plusieurs lignes. Une ligne peut être invalide lorsqu'elle contient un montant négatif ou nul. Dans ce cas, il n'est pas pertinent de continuer à analyser les autres lignes et il vaut mieux passer directement à la commande suivante.
<?php
$commandes = [
[
'id' => 'CMD100',
'lignes' => [10, 0, 3], // contient une ligne invalide (0)
],
[
'id' => 'CMD101',
'lignes' => [50, 20], // commande entièrement valide
],
[
'id' => 'CMD102',
'lignes' => [-5, 7], // contient une ligne invalide (-5)
],
];
foreach ($commandes as $commande)
{
$id = $commande['id'];
foreach ($commande['lignes'] as $montant)
{
// Une ligne est considérée invalide si son montant est négatif ou nul.
if ($montant <= 0)
{
echo "Commande $id ignorée car ligne invalide ($montant €)" . PHP_EOL;
// "continue 2" quitte cette boucle interne
// et demande immédiatement à la boucle externe
// de passer à la commande suivante.
continue 2;
}
// Traitement normal d'une ligne valide.
echo "Commande $id, ligne de $montant €" . PHP_EOL;
}
// Si l'exécution arrive ici, toutes les lignes de la commande sont valides.
echo "Commande $id traitée complètement." . PHP_EOL;
}
?>
Dans cet exemple, continue 2 permet d'ignorer une commande entière dès qu'une ligne invalide est détectée. La boucle interne s'interrompt immédiatement et la boucle externe passe directement à la prochaine commande. Une structure conditionnelle seule ne pourrait pas modifier le déroulement de deux niveaux de boucles en une seule instruction.
Exercices
Exo-boucles-01
- Objectif : Utiliser une boucle while pour traiter une série de tâches en attente dans un système.
- Instructions :
- Créez un fichier exo-boucles-01.php.
- Déclarez une variable $tacheCourante avec la valeur 1. Déclarez ensuite une variable $nombreTotalTaches avec la valeur 5.
- Écrivez une boucle while qui s'exécute tant que $tacheCourante est inférieure ou égale à $nombreTotalTaches.
-
À chaque itération de la boucle, affichez exactement la phrase suivante dans le terminal :
"Traitement de la tâche numéro X..."
où X doit être remplacé par la valeur actuelle de $tacheCourante. - Incrémentez $tacheCourante à chaque tour de boucle afin d'éviter une boucle infinie.
- Exécutez le script et vérifiez que les messages affichés vont bien de la tâche numéro 1 à la tâche numéro 5.
Exo-boucles-02
- Objectif : Utiliser une boucle while pour simuler un système de tentatives de connexion.
- Instructions :
- Créez un fichier exo-boucles-02.php.
- Déclarez une variable $tentativesRestantes avec la valeur 3. Cette variable représentera le nombre de tentatives de connexion autorisées.
- Déclarez une variable $motDePasseCorrect contenant la chaîne "secret123".
- Déclarez une variable $motDePasseSaisi sans l'initialiser. Elle recevra la valeur saisie par l'utilisateur.
-
Écrivez une boucle while qui s'exécute tant que :
- le mot de passe saisi ne correspond pas à $motDePasseCorrect
- et qu'il reste au moins une tentative disponible.
-
À chaque itération de la boucle :
- Demandez à l'utilisateur de saisir un mot de passe avec readline() et stockez la valeur dans $motDePasseSaisi.
- Diminuez la valeur de $tentativesRestantes de 1.
- Si le mot de passe est incorrect, affichez "Connexion refusée. Tentatives restantes : X" où X doit être remplacé par la valeur de $tentativesRestantes.
-
Après la boucle, utilisez une structure conditionnelle
if...else pour afficher :
- Si le mot de passe a été trouvé à temps : "Connexion réussie. Bienvenue."
- Si toutes les tentatives ont été utilisées sans succès : "Compte bloqué après trop de tentatives."
- Testez plusieurs scénarios en saisissant d'abord un mauvais mot de passe puis le bon, et ensuite uniquement des mots de passe incorrects.
Exo-boucles-03
- Objectif : Utiliser une boucle do...while pour demander à l'administrateur s'il souhaite supprimer un compte utilisateur, en exigeant une réponse "o" (oui) ou "n" (non) au moins une fois.
- Instructions :
- Créez un fichier exo-boucles-03.php.
- Déclarez une variable $reponse sans l'initialiser.
-
Écrivez une boucle do...while qui :
- affiche la question suivante avec readline() : "Confirmez-vous la suppression du compte ? (o/n) :"
- stocke la saisie dans $reponse.
- répète la question tant que $reponse est différente de "o" et différente de "n".
-
Après la boucle, utilisez une structure if...else pour afficher :
- Si la réponse est "o" : "Suppression du compte en cours..."
- Si la réponse est "n" : "Suppression annulée. Aucun changement effectué."
- Testez plusieurs saisies (ex.: "x", "o" et "n") afin de vérifier que la boucle redemande bien une valeur tant qu'elle n'est pas valide.
Exo-boucles-04
- Objectif : Utiliser une boucle for pour générer un journal de traitement.
- Instructions :
- Créez un fichier exo-boucles-04.php.
- Déclarez une variable $nombreLignesJournal avec la valeur 10. Cette variable représentera le nombre de lignes de journal à générer.
- Écrivez une boucle for qui commence à 1 et s'exécute jusqu'à la valeur contenue dans $nombreLignesJournal incluse.
-
À chaque itération, affichez exactement la phrase suivante dans le terminal :
"Ligne de journal X sur Y générée."
où X correspond au numéro de l'itération en cours et Y correspond à la valeur de $nombreLignesJournal. - Modifiez la valeur de $nombreLignesJournal (ex.: 5 ou 3) et vérifiez que le nombre de lignes générées s'adapte correctement.
Exo-boucles-05
- Objectif : Utiliser une boucle for pour générer un tableau de nombres puis l'analyser à l'aide des index.
- Instructions :
- Créez un fichier exo-boucles-05.php.
- Déclarez une variable $limite contenant une valeur entière positive par exemple 5. Cette variable représentera le nombre d'éléments à générer.
- Déclarez un tableau vide nommé $nombres.
-
Écrivez une première boucle for
qui remplit le tableau $nombres en ajoutant un élément
à chaque itération.
L'élément ajouté doit être égal à l'index de l'itération + 1.
-
Après la boucle, affichez le tableau $nombres dans le terminal
avec print_r() afin de vérifier son contenu.
Si tout s'est déroulé comme prévu, vous devriez obtenir le tableau suivant :
Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 ) - Écrivez ensuite une seconde boucle for qui parcourt le tableau $nombres à l'aide de son index.
-
À chaque itération de cette seconde boucle, affichez une phrase dans le terminal
qui suit exactement le modèle suivant en remplaçant les valeurs par l'index courant
et la valeur associée :
"À l'index X, la valeur est Y."
où X doit être remplacé par l'index de l'itération courante et Y doit être remplacé par la valeur présente dans le tableau $nombres à cet index. -
Si la seconde boucle fonctionne correctement, le terminal doit afficher exactement :
À l'index 0, la valeur est 1. À l'index 1, la valeur est 2. À l'index 2, la valeur est 3. À l'index 3, la valeur est 4. À l'index 4, la valeur est 5. - Modifiez la valeur de $limite pour tester d'autres tailles de tableau et vérifiez que les messages affichés correspondent bien au contenu du tableau.
Exo-boucles-06
- Objectif : Utiliser une boucle foreach pour calculer le total d'une commande.
- Instructions :
- Créez un fichier exo-boucles-06.php.
-
Déclarez un tableau $lignesCommande
qui représente des lignes de commande.
Chaque élément du tableau doit être un prix en euros :
$lignesCommande = [19.99, 5.5, 3.2, 12]; - Déclarez une variable $total avec la valeur 0. Cette variable stockera le montant total de la commande.
- Parcourez le tableau $lignesCommande avec une boucle foreach. À chaque itération, ajoutez le prix courant à la variable $total.
-
À la fin de la boucle, affichez exactement la phrase suivante dans le terminal :
"Total de la commande : X €"
où X doit être remplacé par la valeur réelle de $total. - Modifiez légèrement les valeurs du tableau $lignesCommande et vérifiez que le total affiché s'adapte correctement.
Exo-boucles-07
- Objectif : Utiliser foreach avec clés et valeurs pour parcourir une liste d'utilisateurs.
- Instructions :
- Créez un fichier exo-boucles-07.php.
-
Déclarez un tableau associatif $utilisateurs
où chaque clé représente un identifiant d'utilisateur et chaque valeur représente son rôle :
- 'u123' : 'admin'
- 'u456' : 'editor'
- 'u789' : 'user'
- Parcourez le tableau $utilisateurs avec une boucle foreach utilisant à la fois la clé et la valeur.
- À chaque itération, affichez exactement la phrase suivante dans le terminal : "Utilisateur ID X possède le rôle Y." où X doit être remplacé par la clé et Y par le rôle associé.
Exo-boucles-08
- Objectif : Utiliser une boucle for et la fonction count() pour vérifier des stocks produits.
- Instructions :
- Créez un fichier exo-boucles-08.php.
-
Déclarez un tableau idexé $produits
contenant trois produits représentés sous forme de tableaux associatifs.
Chaque produit doit avoir une clé 'nom'
et une clé 'stock' :
- 0 :
- 'nom' : 'Clavier'
- 'stock' : 10
- 1 :
- 'nom' : 'Souris'
- 'stock' : 0
- 2 :
- 'nom' : 'Écran'
- 'stock' : 3
- 0 :
- Déclarez une variable $produitsEnRupture initialisée à 0. Elle servira à compter le nombre de produits en rupture de stock.
- Utilisez une boucle for pour parcourir le tableau $produits en utilisant count($produits) comme limite.
-
À chaque itération :
- Récupérez le nom du produit courant dans une variable $nomProduit.
- Récupérez le stock du produit courant dans une variable $stockProduit.
- Si $stockProduit est égal à 0, affichez "Produit X en rupture de stock." où X doit être remplacé par la valeur associée à la clé 'nom' dans l'élément courant du tableau $stockProduits. Incrémentez ensuite la variable $produitsEnRupture.
- Après la boucle, affichez la phrase "Nombre total de produits en rupture : X" où X doit être remplacé par la valeur de $produitsEnRupture.
- Passez le stock des claviers à 0 et relancez le script pour observer la mise à jour des messages.
Exo-boucles-09
- Objectif : Parcourir une chaîne UTF-8 caractère par caractère en utilisant des fonctions multioctets.
- Instructions :
- Créez un fichier exo-boucles-09.php.
- Déclarez une variable $texte contenant la phrase "L'été avance doucement".
- Utilisez la fonction mb_strlen pour obtenir le nombre réel de caractères présents dans la chaîne. Travaillez en UTF-8 en précisant l'encodage dans l'appel de la fonction.
- Écrivez une boucle for qui parcourt la chaîne caractère par caractère.
- À chaque itération, utilisez la fonction mb_substr pour extraire un seul caractère complet.
- Affichez ensuite exactement la phrase suivante dans le terminal "Caractère X détecté : Y" où X représente l'index de l'itération et Y représente le caractère extrait.
- Testez ensuite le script avec d'autres chaînes contenant des accents telles que "année" ou "cœur".
Exo-boucles-10
- Objectif : Convertir une chaîne accentuée en chaîne sans accent à l'aide d'une table de correspondance.
- Instructions :
- Créez un fichier exo-boucles-10.php.
- Déclarez une variable $texteOriginal contenant la chaîne "Élévation du niveau d'été".
-
Déclarez ensuite un tableau associatif nommé
$correspondances
qui servira de table de correspondance entre les caractères accentués
et leurs équivalents non accentués.
Par exemple :
$correspondances = [ 'é' => 'e', 'è' => 'e', 'ê' => 'e', 'à' => 'a', 'â' => 'a', 'î' => 'i', 'ô' => 'o', 'ù' => 'u', 'É' => 'E' ]; - Une table de correspondance permet de remplacer facilement un ensemble de caractères en parcourant la chaîne initiale caractère par caractère et en vérifiant si le caractère courant existe dans le tableau. Si c'est le cas, on utilise la valeur correspondante sinon on conserve le caractère d'origine.
- Utilisez la fonction mb_strlen pour obtenir le nombre de caractères réels dans $texteOriginal.
- Parcourez la chaîne avec une boucle for et la fonction mb_substr pour extraire un caractère complet à chaque itération.
-
À chaque tour de boucle, construisez progressivement une nouvelle chaîne
nommée $texteNettoye.
Utilisez la règle suivante :
- si le caractère extrait apparaît dans la table $correspondances utilisez la valeur correspondante,
- sinon ajoutez simplement le caractère d'origine.
- Après la boucle, affichez exactement la phrase suivante "Texte nettoyé : X" où X est la valeur finale de $texteNettoye.
- Testez votre script en ajoutant de nouveaux caractères dans la table pour améliorer la qualité du nettoyage par exemple "ç" ou "ô".
Exo-boucles-11
- Objectif : Utiliser deux boucles foreach imbriquées pour parcourir des commandes et calculer le total de chaque commande.
- Instructions :
- Créez un fichier exo-boucles-11.php.
-
Déclarez un tableau idexé $commandes
contenant deux commandes représentés sous forme de tableaux associatifs.
Chaque produit doit avoir une clé 'id'
qui contient l'identifiant de la commande sous forme de chaîne de caractères.
et une clé 'lignes'
qui contient un tableau indexé de montants en euros (nombres) :
- 0 :
- 'id' : 'CMD001'
- 'lignes' :
- 0 : 10
- 1 : 5.5
- 1 :
- 'id' : 'CMD002'
- 'lignes' :
- 0 : 20
- 1 : 3
- 2 : 7.5
- 0 :
-
Parcourez le tableau $commandes
avec une première boucle foreach.
À chaque itération de cette première boucle, stockez :
- l'identifiant de la commande dans une variable $idCommande,
- le tableau des montants de la commande courante dans une variable $lignes.
- Toujours à l'intérieur de la première boucle foreach, déclarez une variable $totalCommande initialisée à 0.
- Parcourez ensuite le tableau $lignes avec une seconde boucle foreach. À chaque itération de cette seconde boucle, ajoutez le montant de la ligne courante à $totalCommande.
- Une fois la seconde boucle terminée (toutes les lignes d'une même commande ont été parcourues), affichez la phrase "Commande X : total Y €" dans le terminal où X doit être remplacé par la valeur de $idCommande et Y doit être remplacé par la valeur finale de $totalCommande.
- Exécutez le script et vérifiez que chaque commande affiche bien un total correspondant à la somme de ses lignes.
Exo-boucles-12
- Objectif : Utiliser les instructions break et continue dans le cadre d'une recherche dans un journal d'événements.
- Instructions :
- Créez un fichier exo-boucles-12.php.
-
Déclarez un tableau indexé $journal
contenant des chaînes de caractères représentant des messages du système.
Mélangez des messages informatifs et un message d'erreur :
$journal = [ 'INFO Démarrage du service', 'INFO Connexion utilisateur', 'ERROR Échec de connexion à la base de données', 'INFO Tentative de reconnexion', 'INFO Service arrêté' ]; - Parcourez le tableau $journal avec une boucle foreach.
-
À chaque itération :
- Commencez par vérifier si le message courant débute par "INFO" ou "ERROR". La fonction prédéfinie str_starts_with(), qui permet de vérifier directement si une chaîne commence par un texte donné, serait tout à fait appropriée dans un cas réel. Toutefois, pour cet exercice, utilisez plutôt substr(), afin de vous familiariser avec l'extraction d'une portion de chaîne avant comparaison. Consultez la documentation officielle sur php.net pour voir comment l'utiliser.
- Si le message courant commence par "INFO", utilisez continue pour passer directement à l'itération suivante sans afficher quoi que ce soit.
- Si le message courant commence par "ERROR", affichez la phrase "Erreur détectée dans le journal : X" où X correspond au message complet. Utilisez ensuite break pour interrompre la boucle.
- Exécutez le script et vérifiez que seule la première erreur rencontrée est affichée.
- Modifiez l'ordre des lignes dans $journal ou ajoutez une erreur plus tôt pour confirmer que la boucle s'arrête dès la première erreur.