PhpBB Lab Académie

Terminer le cours en reprenant le formulaire de contact construit en HTML, créer contact.php, comprendre l’envoi avec POST et les tableaux $_POST et $_SERVER, lire les valeurs reçues de manière contrôlée, effectuer des validations simples côté serveur, afficher les erreurs de façon accessible, réafficher les données textuelles avec htmlspecialchars(), finaliser les trois pages actives en .php et clôturer proprement le fil rouge.

Avant de commencer

Cette leçon est la troisième leçon du dernier chapitre.

C’est également la dernière leçon de ce cours PHP.

Dans la leçon précédente, nous avons créé notre première fonction :

construireMessageConversion()

Nous avons appris à distinguer :

déclaration
appel
paramètre
argument
return

Le dossier du fil rouge contient toujours notamment :

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

Depuis le cours HTML, le formulaire de :

contact.html

possède de vrais champs accessibles.

Mais PHP ne reçoit toujours pas réellement les données lorsqu’il est envoyé.

Nous avons volontairement attendu.

Avant de traiter un formulaire, il fallait comprendre les variables, les types, les conditions, les tableaux, les boucles et les fonctions.

Nous pouvons maintenant réunir ces notions dans un cas concret.

Dans cette dernière leçon, nous allons répondre à cinq questions :

- Comment envoyer les données du formulaire vers PHP ?
- Comment PHP reçoit-il les valeurs avec POST ?
- Pourquoi faut-il valider les données côté serveur ?
- Comment réafficher une donnée reçue sans l’interpréter comme du HTML ?
- Comment terminer proprement le petit projet et le cours ?

À la fin de cette leçon :

- le formulaire sera traité dans

contact.php

;
- les champs essentiels seront vérifiés côté serveur ;
- les erreurs seront présentées clairement ;
- les valeurs seront réaffichées de manière sûre ;
- les trois pages actives du site utiliseront

.php

;
- le fil rouge arrivera à un état cohérent de fin de cours.

Nous n’ajouterons ni base de données, ni session, ni envoi réel d’e-mail.

1. Reprendre le formulaire existant

Notre formulaire contient déjà notamment :

<label for="nom">Votre nom (obligatoire)</label>
<input type="text" id="nom" name="nom" autocomplete="name" required>

<label for="email">Votre adresse e-mail (obligatoire)</label>
<input type="email" id="email" name="email" autocomplete="email" required>

<label for="message">Votre message (obligatoire)</label>
<textarea id="message" name="message" required></textarea>

Il contient également :

- le téléphone ;
- le groupe de boutons radio dans un

fieldset

;
- sa

legend

;
- la case à cocher pour recevoir une copie ;
- le bouton d’envoi.

Nous allons conserver cette structure.

PHP va ajouter la logique côté serveur.

2. Créer contact.php

Créez :

contact.php

en copiant tout le contenu de :

contact.html

Ne supprimez pas encore votre copie HTML.

Nous retrouvons une notion étudiée dès la première leçon :

un fichier .php peut contenir du HTML normal

3. Donner une destination au formulaire

Dans :

contact.php

remplacez :

<form>

par :

<form action="contact.php" method="post">

Nous venons d’ajouter :

action
method

4. Comprendre action

Dans :

action="contact.php"

l’attribut

action

indique la page qui recevra les données.

Ici, la même page :

- affiche le formulaire ;
- reçoit l’envoi ;
- vérifie les valeurs ;
- affiche le résultat.

5. Comprendre POST

Dans :

method="post"

le formulaire demande au navigateur d’envoyer ses données avec une requête :

POST

Pour cette leçon, retenez :

ouvrir normalement contact.php
= afficher la page

envoyer le formulaire en POST
= transmettre ses données au serveur

Nous n’avons pas besoin d’étudier tout le protocole HTTP pour comprendre ce mécanisme.

6. Le rôle de name

Dans :

<input id="nom" name="nom">

l’attribut :

id

sert notamment à relier le champ à son label.

L’attribut :

name

donne le nom utilisé lors de l’envoi.

Par exemple :

name="nom"
→ valeur du nom

name="email"
→ valeur de l’adresse e-mail

name="message"
→ valeur du message

7. Découvrir $_POST

PHP fournit un tableau particulier :

$_POST

Lorsque le formulaire est envoyé avec POST, les valeurs reçues sont accessibles dans ce tableau.

Par exemple :

$_POST['nom']

utilise la clé :

'nom'

qui correspond à :

name="nom"

Nous retrouvons donc les tableaux associatifs étudiés précédemment.

8. Une superglobale

Le tableau :

$_POST

est fourni par PHP.

Il appartient à une catégorie de variables appelées :

superglobales

Pour cette leçon, retenez simplement :

$_POST
= tableau fourni par PHP contenant les données envoyées avec POST

9. Ne pas supposer qu’une valeur existe

Nous ne voulons pas écrire directement :

$nom = $_POST['nom'];

en supposant que la clé existe toujours.

Une requête peut être construite autrement que par notre formulaire.

Nous allons d’abord vérifier la présence de la valeur.

10. Découvrir isset()

PHP fournit :

isset()

Cette fonction permet notamment de vérifier si une clé est définie.

Par exemple :

isset($_POST['nom'])

produit un booléen.

Nous pouvons lire :

la clé nom existe-t-elle dans $_POST ?

11. Vérifier que la valeur est du texte

PHP fournit également :

is_string()

Cette fonction vérifie qu’une valeur est une chaîne de caractères.

Nous pourrons donc éviter d’appliquer nos traitements textuels à une valeur d’un autre type.

12. Retirer les espaces extérieurs avec trim()

PHP fournit :

trim()

Par exemple :

trim('   Michel   ')

produit :

Michel

Nous retirons uniquement les espaces inutiles placés au début et à la fin.

13. Réutiliser les fonctions avec lireTextePost()

Nous pouvons maintenant écrire au début de :

contact.php

la fonction :

function lireTextePost($nomChamp)
{
    if (!isset($_POST[$nomChamp]) || !is_string($_POST[$nomChamp]))
    {
        return '';
    }

    return trim($_POST[$nomChamp]);
}

Cette fonction réutilise :

- un paramètre ;
- un tableau associatif ;
-

isset()

;
-

is_string()

;
- une condition ;
-

!

et

||

;
-

return

.

Nous n’utilisons donc pas les fonctions comme une notion isolée.

Nous les appliquons au fil rouge.

14. Distinguer le premier affichage et l’envoi

Lorsque nous ouvrons simplement :

contact.php

nous ne voulons pas afficher immédiatement des erreurs.

Nous devons savoir si la requête actuelle est un POST.

PHP fournit un autre tableau particulier :

$_SERVER

Nous utiliserons sa clé :

'REQUEST_METHOD'

15. Créer formulaireSoumis

Écrivez :

$formulaireSoumis =
    isset($_SERVER['REQUEST_METHOD'])
    && $_SERVER['REQUEST_METHOD'] === 'POST';

Nous pouvons lire :

le formulaire est soumis
si
la méthode existe
ET
elle vaut strictement POST

La variable :

$formulaireSoumis

est un booléen.

16. Initialiser les valeurs

Avant de traiter un envoi, préparez :

$nom = '';
$email = '';
$telephone = '';
$contactPrefere = '';
$message = '';
$copie = false;

$erreurs = [];
$formulaireValide = false;

Nous retrouvons des chaînes, un booléen et un tableau.

Au premier affichage, le formulaire est simplement vide.

17. Lire les champs après un POST

Ajoutez :

if ($formulaireSoumis)
{
    $nom = lireTextePost('nom');
    $email = lireTextePost('email');
    $telephone = lireTextePost('telephone');
    $contactPrefere = lireTextePost('contact-prefere');
    $message = lireTextePost('message');
}

Chaque argument correspond au

name

du champ HTML.

18. Le cas de la case à cocher

Une case non cochée peut être absente de :

$_POST

Notre case possède :

name="copie"
value="oui"

Dans le bloc POST, ajoutez :

$copie =
    isset($_POST['copie'])
    && is_string($_POST['copie'])
    && $_POST['copie'] === 'oui';

La variable

$copie

vaut donc

true

uniquement lorsque la valeur attendue a été reçue.

19. Pourquoi valider aussi côté serveur ?

Notre HTML possède déjà :

required

et :

type="email"

Ces mécanismes aident l’utilisateur dans le navigateur.

Mais une requête peut être envoyée sans passer par notre formulaire.

Le serveur doit donc vérifier les données qu’il reçoit.

Retenez :

validation HTML
= aide dans le navigateur

validation PHP
= contrôle côté serveur

Les deux sont complémentaires.

20. Préparer le tableau d’erreurs

Nous avons initialisé :

$erreurs = [];

PHP permet d’ajouter un élément à la fin d’un tableau avec :

[]

Par exemple :

$erreurs[] = [
    'champ' => 'nom',
    'message' => 'Indiquez votre nom.'
];

Chaque erreur contient :

champ
= identifiant du champ

message
= explication destinée à l’utilisateur

Nous réutilisons donc les tableaux imbriqués.

21. Valider le nom

Dans le bloc POST, après la lecture des valeurs, commencez par :

$formulaireValide = true;

if ($nom === '')
{
    $formulaireValide = false;

    $erreurs[] = [
        'champ' => 'nom',
        'message' => 'Indiquez votre nom.'
    ];
}

Nous vérifions que le nom n’est pas vide après

trim()

.

22. Valider l’adresse e-mail

Ajoutez :

if ($email === '')
{
    $formulaireValide = false;

    $erreurs[] = [
        'champ' => 'email',
        'message' => 'Indiquez votre adresse e-mail.'
    ];
}

Une chaîne non vide n’est toutefois pas forcément une adresse e-mail correcte.

23. Découvrir filter_var()

PHP fournit :

filter_var()

Pour vérifier une adresse e-mail, nous pouvons utiliser :

FILTER_VALIDATE_EMAIL

Nous pouvons donc compléter :

elseif (filter_var($email, FILTER_VALIDATE_EMAIL) === false)
{
    $formulaireValide = false;

    $erreurs[] = [
        'champ' => 'email',
        'message' => 'Indiquez une adresse e-mail valide.'
    ];
}

Le

elseif

n’est évalué que lorsqu’une valeur a déjà été fournie.

24. Valider le moyen de contact

Les seules valeurs prévues sont :

email
telephone

Créez :

$contactPrefereValide =
    $contactPrefere === 'email'
    || $contactPrefere === 'telephone';

Puis :

if (!$contactPrefereValide)
{
    $formulaireValide = false;

    $erreurs[] = [
        'champ' => 'contact-email',
        'message' => 'Choisissez votre moyen de contact préféré.'
    ];
}

Nous ne faisons pas confiance à n’importe quelle chaîne reçue.

25. Le téléphone devient obligatoire si ce choix est sélectionné

Faites évoluer son label vers :

<label for="telephone">Votre numéro de téléphone (obligatoire si vous choisissez le téléphone)</label>

Puis ajoutez :

if ($contactPrefere === 'telephone' && $telephone === '')
{
    $formulaireValide = false;

    $erreurs[] = [
        'champ' => 'telephone',
        'message' => 'Indiquez votre numéro de téléphone puisque vous avez choisi le contact par téléphone.'
    ];
}

Nous réutilisons :

&&

pour exiger les deux conditions.

26. Valider le message

Ajoutez :

if ($message === '')
{
    $formulaireValide = false;

    $erreurs[] = [
        'champ' => 'message',
        'message' => 'Écrivez votre message.'
    ];
}

Nous disposons maintenant d’une validation simple côté serveur.

27. Validation et affichage sûr sont deux problèmes différents

Une valeur peut être valide pour notre formulaire tout en contenant :

<
>
"
'

Nous ne voulons pas qu’un texte reçu soit interprété comme du HTML lorsque nous le réaffichons.

Nous devons donc préparer la valeur pour son contexte d’affichage.

28. Découvrir htmlspecialchars()

PHP fournit :

htmlspecialchars()

Nous utiliserons :

htmlspecialchars($valeur, ENT_QUOTES, 'UTF-8')

Pour cette leçon :

ENT_QUOTES
= traiter aussi les guillemets simples et doubles

UTF-8
= encodage de notre document

Le but est d’afficher une valeur comme du texte dans le HTML.

29. Créer echapper()

Ajoutez :

function echapper($valeur)
{
    return htmlspecialchars($valeur, ENT_QUOTES, 'UTF-8');
}

Nous pourrons ensuite utiliser :

echapper($nom)

au moment où une donnée utilisateur doit être placée dans le HTML.

Retenez surtout :

validation
= vérifier si la donnée convient

échappement
= préparer la donnée pour son affichage

L’un ne remplace pas l’autre.

30. Afficher un résumé d’erreurs accessible

Avant le formulaire, ajoutez :

<?php if ($formulaireSoumis && !$formulaireValide) { ?>
<section>
    <h2>Le formulaire contient des erreurs</h2>
    <p>Corrigez les éléments suivants :</p>

    <ul>
        <?php foreach ($erreurs as $erreur) { ?>
            <li>
                <a href="#<?php echo echapper($erreur['champ']); ?>">
                    <?php echo echapper($erreur['message']); ?>
                </a>
            </li>
        <?php } ?>
    </ul>
</section>
<?php } ?>

Nous réutilisons :

- une condition ;
- un tableau ;
-

foreach

;
- les clés

champ

et

message

;
- notre fonction d’échappement.

31. Pourquoi les erreurs sont-elles des liens ?

Une erreur contenant :

'champ' => 'email'

produit un lien vers :

#email

Le champ possède déjà :

id="email"

L’utilisateur peut donc activer le lien pour rejoindre directement le champ concerné.

Nous utilisons le HTML natif plutôt que d’ajouter des ARIA inutiles.

32. Conserver les valeurs après une erreur

Pour le nom :

<input
    type="text"
    id="nom"
    name="nom"
    autocomplete="name"
    required
    value="<?php echo echapper($nom); ?>"
>

Appliquez le même principe à :

email
telephone

Pour le message :

<textarea id="message" name="message" required><?php echo echapper($message); ?></textarea>

Ainsi, une erreur ne force pas l’utilisateur à tout ressaisir.

33. Conserver les choix

Pour un bouton radio, nous pouvons produire

checked

avec une condition :

<input
    type="radio"
    id="contact-email"
    name="contact-prefere"
    value="email"
    required
    <?php if ($contactPrefere === 'email') { ?>checked<?php } ?>
>

Le bouton téléphone utilise le même principe avec :

'telephone'

La case à cocher utilise :

<?php if ($copie) { ?>checked<?php } ?>

Nous réutilisons donc les booléens dans le HTML sans perdre la structure native.

34. Afficher la confirmation

Avant le formulaire, ajoutez :

<?php if ($formulaireValide) { ?>
<section>
    <h2>Message reçu</h2>
    <p>Le formulaire a été reçu et validé par PHP.</p>
    <p>Nom : <?php echo echapper($nom); ?></p>
    <p>Adresse e-mail : <?php echo echapper($email); ?></p>
    <p>Message : <?php echo echapper($message); ?></p>
</section>
<?php } ?>

Nous affichons encore les valeurs avec :

echapper()

35. Ce que signifie réellement Message reçu

Dans ce projet :

Message reçu

signifie :

les données ont atteint contact.php
et ont passé nos validations simples

Cela ne signifie pas :

- qu’un e-mail a été envoyé ;
- que le message a été enregistré ;
- qu’il sera disponible lors d’une prochaine requête.

Nous n’annonçons pas une action que notre code n’effectue pas.

36. Aucun stockage permanent

Les variables de

contact.php

existent pendant la requête.

Nous n’utilisons ni session ni base de données.

Le formulaire constitue donc un premier traitement côté serveur,

pas un système complet de messagerie.

37. Vérifier l’échappement

Dans le champ du nom, testez temporairement :

<b>Michel</b>

Après un envoi valide, le texte doit être affiché comme du texte.

Le navigateur ne doit pas créer un nouvel élément

b

à partir de cette valeur.

C’est précisément le rôle de :

htmlspecialchars()

dans notre contexte HTML.

38. Vérifier l’accessibilité après l’ajout de PHP

Le formulaire doit toujours conserver :

- les labels associés ;
- le fieldset ;
- la legend ;
- un bouton d’envoi explicite ;
- un ordre logique ;
- des erreurs textuelles ;
- des liens permettant de rejoindre les champs ;
- la navigation au clavier.

PHP ne doit pas dégrader la structure HTML correctement construite.

39. Finaliser les trois pages actives

Nous avons maintenant :

index.php
contact.php

Créez également :

apropos.php

en copiant :

apropos.html

Cette page n’a pas besoin de nouvelle logique.

Un fichier PHP peut toujours contenir du HTML normal.

40. Mettre à jour la navigation de index.php

Dans :

$pagesPrincipales

utilisez désormais :

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

La boucle

foreach

ne change pas.

Seules les données du tableau évoluent.

41. Mettre à jour les deux autres navigations

Dans :

apropos.php
contact.php

les liens doivent également mener vers :

index.php
apropos.php
contact.php

Nous ne créons pas de système d’inclusion dans cette dernière leçon.

Nous gardons simplement les trois pages cohérentes.

42. Faire évoluer pagesConvertiesPhp

Les trois pages principales sont maintenant actives en PHP.

Dans :

index.php

faites donc évoluer :

$pagesConvertiesPhp = 1;

vers :

$pagesConvertiesPhp = 3;

Cette fois, ce n’est plus une expérience.

L’état du projet a réellement changé.

Nous obtenons :

$pagesRestantes = 0;
$conversionTerminee = true;
$conversionEnCours = false;

La fonction :

construireMessageConversion()

renvoie maintenant :

La conversion PHP du site est terminée.

43. Faire évoluer l’état du formulaire dans index.php

Depuis le début, nous avions :

$formulaireTraite = false;

Dans

index.php

, cette variable représentait l’état de mise en œuvre de la fonctionnalité de contact dans le fil rouge.

Maintenant que

contact.php

traite réellement le formulaire, nous pouvons écrire :

$formulaireTraite = true;

Ne confondez pas :

dans index.php
$formulaireTraite
= la fonctionnalité existe dans le projet

dans contact.php
$formulaireSoumis
= cette requête est-elle un POST ?

$formulaireValide
= cet envoi a-t-il passé les contrôles ?

44. L’état général se termine proprement

Avec :

$pagesConvertiesPhp = 3;
$formulaireTraite = true;
$dernierMessage = null;

nous obtenons notamment :

$conversionAContinuer = false;
$contactAConfigurer = false;
$projetAEncoreDesEtapes = false;

Le message général devient :

Les étapes prévues pour cette phase du projet sont terminées.

Pour la première fois, cette phrase correspond réellement à l’état final du fil rouge.

45. Les anciens fichiers HTML

Une fois les versions PHP vérifiées, les pages actives sont :

index.php
apropos.php
contact.php

Les anciennes pages HTML ont servi de point de sécurité pendant l’apprentissage.

Vous pouvez en garder une copie d’archive en dehors de la version active.

Évitez de maintenir deux versions concurrentes comme si elles étaient toutes les deux les pages définitives.

46. État final du petit site

Le projet actif peut maintenant être résumé ainsi :

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

Nous avons conservé le même projet depuis le cours HTML.

Nous lui avons progressivement ajouté CSS,

puis PHP.

47. Ce que le formulaire ne fait volontairement pas

Le formulaire :

- n’envoie pas réellement d’e-mail ;
- n’enregistre pas les messages ;
- ne crée pas de session ;
- n’utilise pas de base de données.

Une application plus avancée devra également étudier selon ses besoins :

- la protection contre les requêtes forgées ;
- la redirection après un POST réussi ;
- la persistance ;
- l’envoi d’e-mails ;
- l’organisation du code dans plusieurs fichiers ;
- les sessions ;
- PDO et les bases de données.

Ces notions ne doivent pas être comprimées artificiellement dans une dernière leçon.

48. Pourquoi le cours s’arrête ici

L’objectif était :

apprendre les bases de PHP
en les appliquant progressivement au même petit site

Nous avons atteint cet objectif.

Ajouter immédiatement SQL, PDO, CRUD, sessions et une architecture complète transformerait ce cours d’initiation en parcours beaucoup plus long.

Nous arrêtons donc le cours à un point cohérent.

49. Revoir les cinq chapitres

Chapitre 1 :

rôle de PHP
variables
types

Chapitre 2 :

opérateurs
comparaisons
if / else

Chapitre 3 :

elseif
opérateurs logiques
conditions lisibles

Chapitre 4 :

tableaux
tableaux associatifs
foreach

Chapitre 5 :

for
fonctions
formulaire POST et validation

50. HTML, CSS et PHP gardent leur rôle

Le projet final permet de retrouver :

HTML
= structure et sens

CSS
= présentation

PHP
= logique exécutée côté serveur

Le formulaire reste un formulaire HTML accessible.

La feuille

styles.css

continue à gérer la présentation.

PHP reçoit, vérifie et produit les valeurs nécessaires.

51. Les habitudes importantes à conserver

Dans cette dernière leçon, nous avons déjà appliqué plusieurs réflexes :

ne pas supposer qu’une donnée reçue existe

vérifier le type attendu

valider côté serveur

ne pas afficher directement une donnée utilisateur dans le HTML

échapper la valeur au moment de l’affichage

Ces réflexes ne constituent pas toute la sécurité d’une application,

mais ils forment une base correcte.

52. Vérification finale

Avant de considérer le projet terminé pour ce cours, vérifiez :

1.

index.php

,

apropos.php

et

contact.php

s’ouvrent correctement.

2. La navigation mène vers les trois pages PHP.

3.

styles.css

continue à s’appliquer.

4.

ordinateur.jpg

reste affichée.

5. Le formulaire est utilisable au clavier.

6. Les labels sont correctement associés aux champs.

7. Un envoi invalide produit des erreurs compréhensibles.

8. Les liens d’erreurs rejoignent les champs.

9. Les valeurs déjà saisies restent présentes après une erreur.

10. Un envoi valide produit la confirmation.

11. Une chaîne contenant du HTML est affichée comme texte.

12. Aucun

var_dump()

de diagnostic ne reste.

13. Les valeurs de test ont été retirées.

14.

$pagesConvertiesPhp

vaut réellement

3

.

15. Le message d’état général indique que la phase est terminée.

53. Ce que vous devez savoir expliquer à la fin du cours

Vous devez maintenant être capable d’expliquer :

- où PHP est exécuté ;
- ce qu’est une variable ;
- les principaux types ;
- la différence entre attribution et comparaison ;
- le rôle des conditions ;
- le rôle des opérateurs logiques ;
- les tableaux indexés et associatifs ;
-

foreach

et

for

;
- ce qu’est une fonction ;
- la différence entre paramètre et argument ;
- le rôle de

return

;
- le rôle de POST dans notre formulaire ;
- ce que contient

$_POST

;
- pourquoi la validation serveur reste nécessaire ;
- pourquoi une donnée utilisateur ne doit pas être affichée directement ;
- le rôle de

htmlspecialchars()

dans notre HTML ;
- pourquoi HTML, CSS et PHP conservent des responsabilités différentes.

54. Retenez surtout ceci :

recevoir une donnée
ne signifie pas lui faire confiance

valider
= vérifier si la donnée convient au besoin

échapper
= préparer la donnée pour son contexte d’affichage

PHP
= logique côté serveur

HTML
= structure et sens

CSS
= présentation

55. Le cours se termine ici

Le petit site qui était initialement composé de HTML et de CSS possède maintenant une vraie logique PHP.

Nous avons volontairement limité le périmètre pour que chaque notion reste compréhensible et reliée à un besoin concret.

Le projet final n’est pas une application complète de production.

Il constitue une base d’apprentissage cohérente sur laquelle des sujets plus avancés pourront être étudiés séparément.

À ce stade, les objectifs de ce cours d’initiation sont terminés.

Nous partons du formulaire accessible déjà construit en HTML.

Dans :

contact.php

le formulaire devient :

<form action="contact.php" method="post">

Au début du fichier, nous préparons notamment :

function lireTextePost($nomChamp)
{
    if (!isset($_POST[$nomChamp]) || !is_string($_POST[$nomChamp]))
    {
        return '';
    }

    return trim($_POST[$nomChamp]);
}

function echapper($valeur)
{
    return htmlspecialchars($valeur, ENT_QUOTES, 'UTF-8');
}

Puis nous distinguons le premier affichage d’un envoi :

$formulaireSoumis =
    isset($_SERVER['REQUEST_METHOD'])
    && $_SERVER['REQUEST_METHOD'] === 'POST';

Lorsqu’un POST est reçu, nous lisons les valeurs, nous les validons côté serveur et nous construisons un tableau d’erreurs si nécessaire.

Dans le HTML, une valeur reçue est réaffichée avec :

<?php echo echapper($nom); ?>

et non directement avec :

<?php echo $nom; ?>

Le projet final utilise ensuite :

index.php
apropos.php
contact.php

comme trois pages principales actives.

Cette fois, l’exercice final reprend l’ensemble du fil rouge.

1. Créer contact.php

Copiez :

contact.html

vers :

contact.php

sans supprimer votre copie de sécurité avant d’avoir vérifié le résultat.

2. Configurer le formulaire

Utilisez :

<form action="contact.php" method="post">

3. Ajouter les fonctions

Créez :

lireTextePost()

puis :

echapper()

avec la logique expliquée dans la leçon.

4. Détecter un POST

Créez :

$formulaireSoumis

à partir de :

$_SERVER['REQUEST_METHOD']

5. Initialiser et lire les champs

Préparez les variables du formulaire, puis utilisez

lireTextePost()

lorsque

$formulaireSoumis

vaut

true

.

6. Valider côté serveur

Vérifiez :

- le nom ;
- l’e-mail ;
- le moyen de contact ;
- le téléphone lorsque ce moyen est choisi ;
- le message.

Utilisez

filter_var()

avec

FILTER_VALIDATE_EMAIL

.

7. Construire le tableau d’erreurs

Ajoutez les erreurs dans :

$erreurs[]

avec les clés :

champ
message

Puis parcourez-les avec

foreach

.

8. Conserver les valeurs saisies

Réaffichez les valeurs avec :

echapper()

et conservez aussi les choix radio et la case à cocher.

9. Tester plusieurs erreurs

Vérifiez au minimum un nom vide, un e-mail incorrect, l’absence de moyen de contact et un message vide.

10. Tester un envoi valide

Vérifiez que la section :

Message reçu

apparaît uniquement lorsque les contrôles ont réussi.

11. Tester l’échappement

Utilisez temporairement :

<b>Test</b>

dans un champ et vérifiez que cette valeur est affichée comme du texte.

12. Créer apropos.php

Copiez :

apropos.html

vers :

apropos.php

13. Finaliser les navigations

Les trois pages actives doivent pointer vers :

index.php
apropos.php
contact.php

14. Finaliser l’état du fil rouge

Dans

index.php

, utilisez désormais :

$pagesConvertiesPhp = 3;
$formulaireTraite = true;

Vérifiez notamment :

$pagesRestantes = 0;
$conversionTerminee = true;
$conversionEnCours = false;
$projetAEncoreDesEtapes = false;

15. Nettoyer et vérifier

Retirez les

var_dump()

et toutes les données de test.

Testez les trois pages, CSS, l’image, le clavier, les erreurs et un envoi valide.

16. Expliquer le projet final

Sans regarder la correction, expliquez avec vos propres mots :

1. pourquoi le formulaire utilise POST ;
2. ce que contient

$_POST

;
3. pourquoi

isset()

est utile ;
4. pourquoi la validation HTML ne remplace pas PHP ;
5. le rôle de

filter_var()

;
6. le rôle de

htmlspecialchars()

;
7. la différence entre valider et échapper ;
8. pourquoi les erreurs sont liées aux identifiants des champs ;
9. la différence entre

$formulaireSoumis

et

$formulaireValide

;
10. pourquoi le cours s’arrête avant les sessions, PDO et CRUD.

Cette leçon termine le chapitre :

Consolider les bases et finaliser le projet PHP

et termine également le cours.

Nous avons fait évoluer :

contact.html

vers :

contact.php

Nous avons appris que :

method="post"
= envoyer les données du formulaire au serveur

PHP reçoit ces données dans :

$_POST

Nous avons utilisé :

isset()
is_string()
trim()

pour lire les valeurs de manière contrôlée.

Nous avons validé les champs essentiels côté serveur,

notamment l’e-mail avec :

filter_var($email, FILTER_VALIDATE_EMAIL)

Nous avons distingué :

validation
= vérifier si la donnée convient

échappement
= préparer la donnée pour l’affichage

Pour l’affichage HTML, nous avons utilisé :

htmlspecialchars($valeur, ENT_QUOTES, 'UTF-8')

dans une fonction

echapper()

.

Nous avons construit un résumé d’erreurs avec un tableau et

foreach

,

tout en conservant les labels, le fieldset, la legend et les mécanismes HTML natifs.

Enfin, les trois pages actives sont devenues :

index.php
apropos.php
contact.php

Le fil rouge arrive donc à :

$pagesConvertiesPhp = 3;
$conversionTerminee = true;
$formulaireTraite = true;
$projetAEncoreDesEtapes = false;

Le parcours complet a relié :

variables
types
opérateurs
comparaisons
conditions
tableaux
boucles
fonctions
POST
validation
affichage sûr

Retenez surtout ceci :

recevoir une donnée
ne signifie pas lui faire confiance

valider une donnée
ne signifie pas encore l’afficher sûrement

PHP
= logique côté serveur

HTML
= structure et sens

CSS
= présentation

Les bases prévues pour ce cours sont maintenant terminées.

Les sessions, les bases de données, PDO, CRUD et les mécanismes de sécurité plus avancés pourront être étudiés dans une suite distincte, sans surcharger ce cours d’initiation.