PhpBB Lab Académie

Ouvrir le dernier chapitre du cours en continuant dans le même index.php, comprendre pourquoi foreach et for répondent à des besoins différents, apprendre les trois parties d’une boucle for, introduire progressivement un compteur et l’opérateur ++, utiliser l’index pour relire les vraies pages du tableau, conserver foreach pour la navigation lorsqu’il reste plus clair et préparer la création des premières fonctions PHP.

Avant de commencer

Dans la leçon précédente, nous avons terminé le chapitre consacré aux tableaux.

Le dossier du fil rouge contient toujours notamment :

index.html
index.php
apropos.html
contact.html
ordinateur.jpg
styles.css

Dans :

index.php

nous avons maintenant un tableau structuré :

$pagesPrincipales = [
    [
        'titre' => 'Accueil',
        'fichier' => 'index.html'
    ],
    [
        'titre' => 'À propos',
        'fichier' => 'apropos.html'
    ],
    [
        'titre' => 'Contact',
        'fichier' => 'contact.html'
    ]
];

La navigation utilise désormais :

foreach ($pagesPrincipales as $page)

pour parcourir directement les trois pages.

Nous avons donc déjà découvert une première boucle.

Cette leçon ouvre maintenant le cinquième et dernier chapitre du cours.

Ce dernier chapitre contiendra trois leçons.

Nous allons l’utiliser pour consolider les bases essentielles sans transformer ce cours d’initiation en parcours interminable.

Les trois dernières étapes seront :

1. comprendre la boucle for et savoir quand l’utiliser

2. créer et réutiliser ses premières fonctions

3. terminer le projet avec un premier traitement de formulaire côté serveur

Les thèmes plus avancés comme les sessions, PDO ou les opérations CRUD ne seront pas ajoutés artificiellement à la fin de ce cours.

Ils demanderaient un apprentissage séparé pour rester pédagogiques.

Dans cette première leçon du dernier chapitre, nous allons répondre à quatre questions :

- Pourquoi apprendre une autre boucle après

foreach

?
- Comment fonctionne une boucle

for

?
- Quel est le rôle de la valeur de départ, de la condition et de l’évolution ?
- Quand faut-il choisir

for

plutôt que

foreach

?

À la fin de cette leçon, vous saurez écrire une boucle

for

simple et surtout choisir la boucle adaptée au besoin réel.

1. foreach et for ne répondent pas exactement au même besoin

Nous avons utilisé :

foreach

pour dire :

pour chaque page du tableau,
faire la même action

C’est très adapté lorsque notre objectif est de parcourir directement tous les éléments d’un tableau.

Mais certaines répétitions partent plutôt d’un nombre.

Par exemple :

répéter une action 3 fois

compter de 0 à 2

faire évoluer une valeur à chaque passage

Pour ce type de situation, PHP possède notamment :

for

2. Une boucle for repose sur trois informations

La structure générale que nous allons apprendre est :

for (départ; condition; évolution)
{
    ...
}

Nous pouvons la lire ainsi :

1. choisir une valeur de départ

2. vérifier une condition avant chaque passage

3. faire évoluer la valeur après chaque passage

Nous allons maintenant construire ces trois parties séparément.

3. Commencer par une variable de compteur

Nous allons utiliser :

$indexPage

Cette variable représentera un index numérique de notre tableau.

Nous savons déjà que les trois pages utilisent les index :

0
1
2

Nous pouvons donc commencer par :

$indexPage = 0;

Cette instruction signifie :

commencer avec l’index 0

4. Définir la condition de continuation

Nous avons toujours :

$nombrePages = 3;

Nous voulons continuer tant que l’index reste inférieur au nombre de pages.

La comparaison est donc :

$indexPage < $nombrePages

Avec la valeur de départ :

0 < 3

la comparaison est vraie.

La boucle peut commencer.

5. Faire évoluer le compteur

Après un passage, nous voulons passer de :

0

à :

1

puis de :

1

à :

2

Nous savons déjà additionner des nombres.

Nous pourrions donc écrire :

$indexPage = $indexPage + 1;

Cette instruction signifie :

prendre la valeur actuelle de $indexPage

ajouter 1

réattribuer le résultat à $indexPage

6. Construire un premier for sans raccourci

Nous pouvons maintenant réunir les trois parties :

for ($indexPage = 0; $indexPage < $nombrePages; $indexPage = $indexPage + 1)
{
    echo $indexPage;
}

Nous avons :

$indexPage = 0
= départ

$indexPage < $nombrePages
= condition

$indexPage = $indexPage + 1
= évolution

Le bloc est exécuté avec les valeurs :

0
1
2

7. Pourquoi la valeur 3 n’est-elle pas utilisée ?

Lorsque :

$indexPage = 2

la condition est :

2 < 3

Elle est vraie.

Le bloc est exécuté.

Après ce passage, l’évolution produit :

$indexPage = 3

PHP vérifie alors :

3 < 3

Cette comparaison est fausse.

La boucle s’arrête.

Nous obtenons donc exactement :

0
1
2

qui correspondent aux trois index du tableau.

8. Tester temporairement le compteur

Ajoutez temporairement :

for ($indexPage = 0; $indexPage < $nombrePages; $indexPage = $indexPage + 1)
{
    echo $indexPage;
}

Le résultat visible peut être :

012

car nous n’avons ajouté aucun espace ni élément HTML.

C’est normal.

Le but de ce premier test est uniquement d’observer les trois valeurs successives.

Supprimez ensuite ce bloc de test.

9. Découvrir le raccourci ++

PHP permet d’écrire plus simplement :

$indexPage++

pour augmenter la valeur de :

$indexPage

de :

1

Dans notre situation, nous pouvons lire :

$indexPage++
= ajouter 1 à $indexPage

Nous pouvons donc remplacer :

$indexPage = $indexPage + 1

par :

$indexPage++

10. Écrire la forme habituelle de notre boucle

Nous obtenons maintenant :

for ($indexPage = 0; $indexPage < $nombrePages; $indexPage++)
{
    echo $indexPage;
}

Le comportement reste le même.

La forme est simplement plus courte.

11. Les trois parties restent présentes

Même avec :

$indexPage++

la logique ne change pas.

Nous avons toujours :

départ
= $indexPage = 0

condition
= $indexPage < $nombrePages

évolution
= $indexPage++

Retenez surtout le rôle de chaque partie avant de mémoriser la syntaxe complète.

12. Utiliser l’index pour accéder au vrai tableau

La variable :

$indexPage

contient successivement :

0
1
2

Nous pouvons donc l’utiliser à la place d’un index écrit directement.

Par exemple :

$pagesPrincipales[$indexPage]

représente successivement :

$pagesPrincipales[0]

$pagesPrincipales[1]

$pagesPrincipales[2]

13. Accéder au titre pendant la boucle

Nous pouvons écrire :

$pagesPrincipales[$indexPage]['titre']

Au premier passage :

$indexPage = 0

le résultat est :

Accueil

Au deuxième :

À propos

Au troisième :

Contact

14. Faire un test avec les vraies données du fil rouge

Testez temporairement :

for ($indexPage = 0; $indexPage < $nombrePages; $indexPage++)
{
    echo $pagesPrincipales[$indexPage]['titre'];
}

Vous devez retrouver les trois titres dans l’ordre du tableau.

Supprimez ensuite ce test.

15. Ajouter une structure HTML pendant le test

Pour rendre le résultat plus lisible, nous pouvons mélanger PHP et HTML comme avec

foreach

:

<ol>
    <?php for ($indexPage = 0; $indexPage < $nombrePages; $indexPage++) { ?>
        <li><?php echo $pagesPrincipales[$indexPage]['titre']; ?></li>
    <?php } ?>
</ol>

Le navigateur reçoit alors une liste ordonnée avec :

1. Accueil
2. À propos
3. Contact

Cette liste est uniquement une expérience pédagogique.

Nous ne la conserverons pas dans la page finale.

16. Pourquoi la liste affiche 1, 2, 3 alors que les index sont 0, 1, 2 ?

Le navigateur numérote naturellement les éléments d’une liste :

ol

à partir de :

1

Mais PHP utilise toujours ici les index :

0
1
2

Nous avons donc deux notions différentes :

index du tableau
= 0, 1, 2

numérotation visible de la liste HTML
= 1, 2, 3

Il ne faut pas les confondre.

17. Retirer la liste de démonstration

Une fois le test terminé, supprimez le bloc :

<ol>
    ...
</ol>

Notre page n’a pas besoin d’une seconde liste des mêmes pages.

Nous avons utilisé le fil rouge pour comprendre

for

sans ajouter un contenu inutile au projet final.

18. Pourquoi ne remplaçons-nous pas foreach dans la navigation ?

Nous pourrions techniquement produire la navigation avec :

for

en utilisant les index du tableau.

Mais la navigation possède déjà une solution très claire :

foreach ($pagesPrincipales as $page)

Elle exprime directement notre intention :

pour chaque page,
produire un lien

Nous allons donc conserver

foreach

pour la navigation.

19. Choisir foreach quand nous voulons chaque élément

Dans notre navigation, nous ne nous intéressons pas réellement au nombre :

0
1
2

Nous voulons surtout :

prendre chaque page du tableau

Dans ce cas :

foreach

reste le choix le plus naturel.

20. Choisir for quand le compteur fait partie du problème

Une boucle

for

devient particulièrement utile lorsque nous avons besoin :

- d’un compteur ;
- d’une valeur de départ précise ;
- d’une condition numérique ;
- d’une évolution régulière.

Nous pouvons représenter :

foreach
= parcourir directement des éléments

for
= contrôler une répétition avec départ, condition et évolution

21. Ne pas choisir une boucle uniquement parce qu’elle est nouvelle

Apprendre une nouvelle structure ne signifie pas qu’elle doit remplacer les structures déjà adaptées.

Nous ne changeons pas :

foreach

en :

for

simplement parce que

for

est la nouvelle notion de cette leçon.

Nous choisissons l’outil selon le besoin.

C’est une règle importante pour la suite de l’apprentissage.

22. Que se passe-t-il si la condition est fausse dès le départ ?

Imaginons temporairement :

for ($indexPage = 3; $indexPage < $nombrePages; $indexPage++)
{
    echo $indexPage;
}

Avec :

$nombrePages = 3

la première comparaison est :

3 < 3

Elle est fausse.

Le bloc n’est donc exécuté aucune fois.

Comme avec un

if

, la condition joue un rôle essentiel.

23. Que se passe-t-il si l’évolution est incorrecte ?

Une boucle doit pouvoir atteindre une situation où sa condition devient fausse.

Si nous écrivions une logique qui ne fait jamais évoluer correctement le compteur, la boucle pourrait continuer sans atteindre sa fin attendue.

Pour cette leçon, nous conservons donc :

$indexPage++

qui fait évoluer :

0
vers 1
vers 2
vers 3

La condition devient alors fausse au bon moment.

24. Une boucle possède donc un équilibre

Notre boucle fonctionne parce que les trois parties sont cohérentes :

départ
= 0

condition
= inférieur à 3

évolution
= ajouter 1

Nous pouvons suivre mentalement :

0
→ condition vraie

1
→ condition vraie

2
→ condition vraie

3
→ condition fausse
→ arrêt

25. Réutiliser les comparaisons déjà apprises

Dans :

$indexPage < $nombrePages

nous n’apprenons pas une nouvelle comparaison.

Nous réutilisons :

<

étudié dans les leçons sur les opérateurs de comparaison.

La boucle assemble donc plusieurs notions déjà comprises :

variable
+
attribution
+
comparaison
+
addition
+
bloc de code

26. Réutiliser les tableaux déjà appris

Dans :

$pagesPrincipales[$indexPage]['titre']

nous ne découvrons pas non plus une nouvelle forme de tableau.

Nous réutilisons :

- un index numérique ;
- un tableau contenant d’autres tableaux ;
- une clé textuelle.

La nouveauté de cette leçon est uniquement la manière de répéter le bloc.

27. État final du projet après la leçon

À la fin de cette leçon, nous ne conservons aucune boucle

for

de démonstration dans la page.

Le tableau reste :

$pagesPrincipales = [
    [
        'titre' => 'Accueil',
        'fichier' => 'index.html'
    ],
    [
        'titre' => 'À propos',
        'fichier' => 'apropos.html'
    ],
    [
        'titre' => 'Contact',
        'fichier' => 'contact.html'
    ]
];

La navigation reste :

<nav>
    <ul class="navigation-principale">
        <?php foreach ($pagesPrincipales as $page) { ?>
            <li><a href="<?php echo $page['fichier']; ?>"><?php echo $page['titre']; ?></a></li>
        <?php } ?>
    </ul>
</nav>

Nous avons appris

for

sans dégrader une solution déjà claire.

28. Ce dernier chapitre doit rester concentré

Nous arrivons maintenant à la fin des bases de contrôle du langage.

Nous avons appris :

if
elseif
else

foreach
for

Il serait possible de multiplier encore les structures et les variantes.

Ce n’est pas l’objectif de ce cours.

Nous voulons maintenant apprendre à éviter la répétition autrement :

en donnant un nom à un bloc de logique réutilisable

29. Préparer les fonctions

Regardons une idée déjà présente dans le projet.

Nous construisons plusieurs messages à partir de valeurs :

$messageAccueil
$messageConversion
$messageEtatProjet

Une partie de cette logique pourrait être regroupée sous un nom afin d’être appelée lorsqu’on en a besoin.

PHP permet cela avec :

une fonction

Nous n’allons pas encore écrire de fonction dans cette leçon.

Nous allons l’expliquer depuis le début dans la suivante.

30. Ce que nous ferons dans la prochaine leçon

Dans la prochaine leçon, nous apprendrons :

- ce qu’est une fonction ;
- comment la déclarer ;
- comment l’appeler ;
- ce qu’est un paramètre ;
- ce qu’est un argument ;
- comment renvoyer une valeur avec

return

.

Nous construirons une fonction simple à partir d’une logique déjà connue du fil rouge.

Nous éviterons ainsi d’introduire une fonction abstraite sans rapport avec le projet.

31. Pourquoi les fonctions sont la bonne prochaine étape

Nous savons déjà :

- manipuler des valeurs ;
- prendre des décisions ;
- organiser des données ;
- répéter des blocs.

La prochaine difficulté n’est plus :

comment exécuter une instruction ?

mais plutôt :

comment organiser une logique pour pouvoir la nommer et la réutiliser ?

Les fonctions répondent précisément à cette question.

32. Le dernier chapitre suivra donc cette progression

Nous avançons maintenant dans cet ordre :

leçon 13
= maîtriser une répétition contrôlée avec for

leçon 14
= organiser une logique réutilisable avec une fonction

leçon 15
= réutiliser les bases dans un premier traitement de formulaire et terminer le cours

Nous garderons le même projet jusqu’à la dernière leçon.

33. Ce que vous devez comprendre avant la prochaine leçon

Vous devez maintenant être capable d’expliquer :

- la différence générale entre

foreach

et

for

;
- les trois parties d’une boucle

for

;
- le rôle de

$indexPage = 0

;
- le rôle de

$indexPage < $nombrePages

;
- le rôle de

$indexPage++

;
- pourquoi notre boucle utilise les valeurs

0

,

1

et

2

;
- pourquoi la valeur

3

arrête la boucle ;
- ce qu’est une itération ;
- comment utiliser

$indexPage

pour accéder à un élément de

$pagesPrincipales

;
- pourquoi nous avons retiré la liste de démonstration ;
- pourquoi la navigation continue à utiliser

foreach

;
- dans quel type de situation

for

devient utile ;
- pourquoi une boucle doit pouvoir atteindre une condition fausse.

Retenez surtout ceci :

for (départ; condition; évolution)
{
    bloc répété
}

foreach
= parcourir directement les éléments d’un tableau

for
= contrôler une répétition avec un compteur

Dans la prochaine leçon, nous garderons le même fil rouge et nous apprendrons à créer notre première fonction PHP afin de regrouper une logique sous un nom et de récupérer le résultat qu’elle produit.

Nous disposons déjà de :

$nombrePages = 3;

et de :

$pagesPrincipales

avec les index :

0
1
2

Nous pouvons écrire :

for ($indexPage = 0; $indexPage < $nombrePages; $indexPage++)
{
    echo $pagesPrincipales[$indexPage]['titre'];
}

La boucle fonctionne ainsi :

$indexPage = 0
→ Accueil

$indexPage = 1
→ À propos

$indexPage = 2
→ Contact

$indexPage = 3
→ 3 < 3 est faux
→ arrêt

Nous ne remplaçons pas pour autant la navigation en

foreach

.

Dans cette navigation,

foreach

reste plus clair parce que notre besoin est simplement de traiter chaque page du tableau.

Continuez dans le même fichier :

index.php

1. Conserver le tableau et la navigation actuels

Ne modifiez pas définitivement :

$pagesPrincipales

ni la navigation en

foreach

.

2. Tester la forme longue de for

Ajoutez temporairement :

for ($indexPage = 0; $indexPage < $nombrePages; $indexPage = $indexPage + 1)
{
    echo $indexPage;
}

Vérifiez que vous obtenez les valeurs :

0
1
2

puis supprimez le test.

3. Utiliser le raccourci ++

Refaites le test avec :

for ($indexPage = 0; $indexPage < $nombrePages; $indexPage++)
{
    echo $indexPage;
}

Vérifiez que le résultat logique reste le même.

4. Lire les vrais titres du tableau

Testez :

for ($indexPage = 0; $indexPage < $nombrePages; $indexPage++)
{
    echo $pagesPrincipales[$indexPage]['titre'];
}

Repérez :

Accueil
À propos
Contact

puis retirez ce bloc.

5. Produire temporairement une liste ordonnée

Testez :

<ol>
    <?php for ($indexPage = 0; $indexPage < $nombrePages; $indexPage++) { ?>
        <li><?php echo $pagesPrincipales[$indexPage]['titre']; ?></li>
    <?php } ?>
</ol>

Vérifiez que les trois pages apparaissent.

Supprimez ensuite cette liste de démonstration.

6. Conserver foreach dans la navigation

La navigation finale doit toujours utiliser :

foreach ($pagesPrincipales as $page)

Expliquez pourquoi ce choix reste plus lisible ici.

7. Vérifier l’état final

Aucun test

for

ne doit rester dans la page.

Le projet doit conserver exactement le même contenu utile qu’avant la leçon.

8. Expliquer ce que vous avez fait

Sans regarder la correction, expliquez avec vos propres mots :

1. les trois parties d’une boucle

for

;
2. pourquoi nous commençons à

0

;
3. pourquoi la condition utilise

< $nombrePages

;
4. ce que signifie

$indexPage++

;
5. pourquoi la boucle s’arrête lorsque l’index vaut

3

;
6. comment l’index permet d’accéder au tableau ;
7. pourquoi nous gardons

foreach

pour la navigation ;
8. quelle nouvelle notion permettra dans la prochaine leçon de nommer une logique réutilisable.

Cette leçon ouvre le cinquième et dernier chapitre du cours :

Consolider les bases et finaliser le projet PHP

Nous avons découvert :

for

Une boucle

for

possède trois parties :

départ
condition
évolution

Dans notre fil rouge :

for ($indexPage = 0; $indexPage < $nombrePages; $indexPage++)
{
    ...
}

signifie :

commencer à 0

continuer tant que l’index est inférieur au nombre de pages

ajouter 1 après chaque passage

Nous avons utilisé ce compteur pour accéder successivement aux trois pages réelles du tableau.

Nous avons également retenu qu’apprendre

for

ne signifie pas remplacer

foreach

partout.

Pour la navigation :

foreach

reste plus lisible.

Le dernier chapitre comptera trois leçons seulement.

La prochaine sera consacrée aux fonctions.

La dernière réutilisera les bases essentielles pour traiter un premier formulaire côté serveur et conclure le cours.