PhpBB Lab Académie

Continuer dans le même index.php, comprendre le rôle d’une fonction, distinguer déclaration et appel, paramètres et arguments, découvrir return, regrouper la logique déjà connue du message de conversion dans une fonction construireMessageConversion, récupérer sa valeur sans modifier le HTML existant et préparer la dernière leçon consacrée au traitement accessible et sûr du formulaire de contact côté serveur.

Avant de commencer

Dans la leçon précédente, nous avons ouvert le dernier chapitre du cours.

Nous avons découvert :

for

et nous avons surtout appris à choisir entre :

foreach
et
for

selon le besoin réel.

Le dossier du fil rouge contient toujours notamment :

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

Dans :

index.php

la navigation continue à utiliser :

foreach ($pagesPrincipales as $page)

car cette structure reste la plus claire pour parcourir directement les pages du tableau.

Nous avons maintenant appris à :

- créer des variables ;
- manipuler plusieurs types de valeurs ;
- construire des expressions ;
- comparer des valeurs ;
- prendre des décisions ;
- regrouper des données dans des tableaux ;
- parcourir un tableau ;
- répéter un bloc avec une boucle contrôlée.

Une nouvelle question apparaît :

comment donner un nom à une logique
pour pouvoir l’utiliser proprement lorsque nous en avons besoin ?

PHP répond à cette question avec :

les fonctions

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

La prochaine sera la dernière du cours.

Dans cette leçon, nous allons répondre à quatre questions :

- Qu’est-ce qu’une fonction ?
- Comment déclarer puis appeler une fonction ?
- Quelle différence existe entre un paramètre et un argument ?
- Comment une fonction peut-elle produire une valeur avec

return

?

À la fin de cette leçon, nous aurons regroupé une logique déjà connue du fil rouge dans une fonction nommée :

construireMessageConversion

Nous n’allons pas inventer une logique nouvelle.

Nous allons organiser autrement une logique que nous savons déjà expliquer.

1. Qu’est-ce qu’une fonction ?

Une fonction permet de regrouper un bloc de logique sous un nom.

Nous pouvons retenir :

fonction
= bloc de logique auquel nous donnons un nom

Une fois la fonction définie,

nous pouvons demander à PHP de l’exécuter en utilisant ce nom.

2. Nous avons déjà utilisé des fonctions fournies par PHP

Depuis plusieurs leçons, nous avons utilisé :

var_dump()

Cette fonction est déjà fournie par PHP.

Nous l’avons utilisée pour observer une valeur pendant les tests.

Nous n’avons pas écrit nous-mêmes le code interne de :

var_dump()

Nous avons seulement appelé cette fonction.

Dans cette leçon, nous allons créer notre propre fonction.

3. Fonction fournie et fonction créée dans le projet

Nous pouvons distinguer :

fonction fournie par PHP
= déjà disponible

fonction créée dans notre projet
= logique que nous définissons nous-mêmes

Notre première fonction personnalisée sera liée directement au fil rouge.

4. Reprendre une logique qui existe déjà

Nous avons actuellement une décision comme :

if ($conversionTerminee)
{
    $messageConversion = 'La conversion PHP du site est terminée.';
}
elseif ($conversionEnCours)
{
    $messageConversion = 'La conversion PHP du site est en cours : ' . $pagesRestantes . ' pages restent à faire évoluer.';
}
else
{
    $messageConversion = 'La conversion PHP du site n’a pas encore commencé.';
}

Cette logique fonctionne.

Nous savons expliquer chaque condition.

Nous allons maintenant lui donner un nom.

5. Choisir un nom clair

La logique construit :

le message décrivant l’état de la conversion

Nous choisissons donc :

construireMessageConversion

Le nom commence par un verbe :

construire

et indique ce que la fonction produit :

MessageConversion

Nous évitons un nom vague comme :

faireTruc

ou :

fonction1

6. Découvrir le mot function

Pour déclarer une fonction en PHP, nous utilisons :

function

La structure la plus simple ressemble à :

function nomDeLaFonction()
{
    ...
}

Nous avons donc :

function
= indiquer que nous déclarons une fonction

nomDeLaFonction
= nom choisi

()
= emplacement des paramètres éventuels

{}
= bloc de la fonction

7. Commencer la déclaration de notre fonction

Au début de :

index.php

après :

<?php

nous pouvons commencer par :

function construireMessageConversion()
{
}

Pour le moment, la fonction ne contient encore aucune logique.

Nous allons la construire progressivement.

8. Une fonction peut avoir besoin de valeurs

Notre ancienne logique utilise :

$conversionTerminee
$conversionEnCours
$pagesRestantes

La fonction doit donc recevoir ces informations.

Nous allons les placer entre les parenthèses de la déclaration.

9. Découvrir les paramètres

Écrivez :

function construireMessageConversion($conversionTerminee, $conversionEnCours, $pagesRestantes)
{
}

Les trois noms placés entre parenthèses sont :

des paramètres

Un paramètre est une variable prévue par la fonction pour recevoir une valeur lors de son appel.

Nous pouvons retenir :

paramètre
= variable déclarée dans la fonction pour recevoir une valeur

10. Pourquoi trois paramètres ?

La fonction a besoin de trois informations différentes :

$conversionTerminee
= savoir si la conversion est terminée

$conversionEnCours
= savoir si la conversion est en cours

$pagesRestantes
= construire le message de progression

Nous ne transmettons donc pas des valeurs au hasard.

Chaque paramètre correspond à une donnée nécessaire à la logique.

11. Les paramètres appartiennent au travail de la fonction

À l’intérieur de la fonction :

$conversionTerminee
$conversionEnCours
$pagesRestantes

représentent les valeurs reçues au moment de l’appel.

Pour cette leçon, retenez simplement :

la fonction travaille avec les valeurs reçues dans ses paramètres

Nous n’allons pas utiliser :

global

pour aller chercher directement des variables extérieures.

Nous préférons transmettre clairement les informations nécessaires.

12. Remettre la logique déjà connue dans la fonction

Nous pouvons maintenant écrire :

function construireMessageConversion($conversionTerminee, $conversionEnCours, $pagesRestantes)
{
    if ($conversionTerminee)
    {
        $message = 'La conversion PHP du site est terminée.';
    }
    elseif ($conversionEnCours)
    {
        $message = 'La conversion PHP du site est en cours : ' . $pagesRestantes . ' pages restent à faire évoluer.';
    }
    else
    {
        $message = 'La conversion PHP du site n’a pas encore commencé.';
    }
}

Nous n’avons introduit aucune nouvelle condition.

Nous avons simplement déplacé la décision dans la fonction.

13. La variable message est interne à cette logique

Dans la fonction, nous utilisons :

$message

Cette variable reçoit l’une des trois phrases.

Elle sert uniquement à construire le résultat de la fonction.

Nous n’avons pas besoin de lui donner le même nom que :

$messageConversion

qui sera utilisé plus tard dans le reste du projet.

14. La fonction doit encore rendre son résultat

Pour le moment, la fonction calcule :

$message

mais le reste du programme ne récupère encore rien.

Nous devons demander à la fonction de renvoyer cette valeur.

PHP utilise pour cela :

return

15. Découvrir return

Ajoutez à la fin de la fonction :

return $message;

La fonction devient :

function construireMessageConversion($conversionTerminee, $conversionEnCours, $pagesRestantes)
{
    if ($conversionTerminee)
    {
        $message = 'La conversion PHP du site est terminée.';
    }
    elseif ($conversionEnCours)
    {
        $message = 'La conversion PHP du site est en cours : ' . $pagesRestantes . ' pages restent à faire évoluer.';
    }
    else
    {
        $message = 'La conversion PHP du site n’a pas encore commencé.';
    }

    return $message;
}

Nous pouvons lire :

return $message;
= renvoyer la valeur contenue dans $message

16. return et echo n’ont pas le même rôle

Nous connaissons déjà :

echo

qui envoie une valeur dans la sortie produite.

Mais :

return

ne signifie pas :

afficher dans la page

Il signifie ici :

rendre une valeur à l’endroit où la fonction a été appelée

Cette différence est importante.

17. Déclarer une fonction ne l’exécute pas encore pour notre message

Lorsque nous écrivons :

function construireMessageConversion(...)
{
    ...
}

nous définissons la fonction.

Nous indiquons à PHP :

voici une logique portant ce nom

Pour obtenir un résultat dans le projet,

nous devons ensuite :

appeler la fonction

18. Appeler une fonction

Un appel utilise le nom de la fonction suivi de parenthèses.

Par exemple :

construireMessageConversion(...)

Entre les parenthèses,

nous allons fournir les valeurs nécessaires.

19. Découvrir les arguments

Après avoir calculé :

$conversionTerminee
$conversionEnCours
$pagesRestantes

nous pouvons écrire :

construireMessageConversion(
    $conversionTerminee,
    $conversionEnCours,
    $pagesRestantes
);

Les valeurs fournies lors de l’appel sont :

des arguments

Nous pouvons retenir :

paramètre
= nom prévu dans la déclaration

argument
= valeur fournie lors de l’appel

20. Relier paramètres et arguments

La déclaration contient :

function construireMessageConversion(
    $conversionTerminee,
    $conversionEnCours,
    $pagesRestantes
)

L’appel contient :

construireMessageConversion(
    $conversionTerminee,
    $conversionEnCours,
    $pagesRestantes
);

Dans cet appel, les noms se ressemblent parce que nous transmettons directement les variables du projet.

Mais il faut retenir surtout l’ordre.

Le premier argument alimente le premier paramètre.

Le deuxième argument alimente le deuxième paramètre.

Le troisième argument alimente le troisième paramètre.

21. L’ordre des arguments compte

Notre fonction attend :

1. conversionTerminee

2. conversionEnCours

3. pagesRestantes

Nous devons donc respecter cet ordre.

Nous n’écrirons pas :

construireMessageConversion(
    $pagesRestantes,
    $conversionTerminee,
    $conversionEnCours
);

Cette écriture donnerait aux paramètres des valeurs qui ne correspondent pas à leur rôle.

22. Récupérer la valeur renvoyée

Notre fonction utilise :

return $message;

Nous pouvons donc récupérer son résultat dans une variable :

$messageConversion = construireMessageConversion(
    $conversionTerminee,
    $conversionEnCours,
    $pagesRestantes
);

PHP exécute la fonction.

La fonction renvoie une chaîne de caractères.

Cette chaîne est attribuée à :

$messageConversion

23. Lire l’instruction complète

Nous pouvons lire :

$messageConversion = construireMessageConversion(
    $conversionTerminee,
    $conversionEnCours,
    $pagesRestantes
);

ainsi :

appeler construireMessageConversion

lui fournir les trois valeurs nécessaires

récupérer la valeur renvoyée

attribuer cette valeur à $messageConversion

24. Tester avec l’état réel du fil rouge

Nous avons toujours :

$pagesConvertiesPhp = 1;

Donc :

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

La fonction reçoit donc l’équivalent de :

false
true
2

Le bloc :

elseif ($conversionEnCours)

est choisi.

La fonction renvoie :

La conversion PHP du site est en cours : 2 pages restent à faire évoluer.

25. Le HTML ne change pas

Dans le contenu principal, nous conservons :

<p><?php echo $messageConversion; ?></p>

Le HTML n’a pas besoin de savoir que la valeur est maintenant construite par une fonction.

Il reçoit toujours une chaîne de caractères.

Nous conservons donc :

PHP
= calculer et organiser la logique

HTML
= structurer le contenu

26. Remplacer l’ancien bloc par l’appel

Une fois la fonction créée,

nous ne conservons pas l’ancien bloc complet :

if ($conversionTerminee)
{
    ...
}
elseif ($conversionEnCours)
{
    ...
}
else
{
    ...
}

à l’endroit où il se trouvait auparavant.

Cette logique existe maintenant dans :

construireMessageConversion()

À l’endroit de l’ancien bloc, nous utilisons seulement :

$messageConversion = construireMessageConversion(
    $conversionTerminee,
    $conversionEnCours,
    $pagesRestantes
);

27. Nous n’avons pas supprimé la logique

Il est important de comprendre ce qui vient de se passer.

Nous n’avons pas supprimé :

- les conditions ;
- la concaténation ;
- les variables ;
- les booléens.

Nous les avons regroupés dans une fonction.

Nous avons donc transformé :

une logique écrite directement dans le déroulement principal

en :

une logique portant un nom clair

28. Pourquoi cette fonction est utile pédagogiquement

Le nom :

construireMessageConversion

permet de comprendre immédiatement l’intention de l’appel.

Nous n’avons plus besoin de relire toute la décision chaque fois que nous voyons :

$messageConversion = construireMessageConversion(...);

Le détail reste disponible dans la fonction.

Le déroulement principal devient plus lisible.

29. Une fonction ne doit pas forcément être longue

Nous pourrions créer une fonction contenant seulement quelques instructions.

La taille n’est pas le critère principal.

La question est plutôt :

est-ce que ce bloc possède un rôle clair
que nous pouvons nommer ?

Dans notre cas :

construire un message de conversion

est un rôle identifiable.

30. Ne pas créer une fonction pour chaque ligne

Comme avec les variables intermédiaires,

nous ne devons pas créer des fonctions sans raison.

Il serait inutile de transformer :

$nombrePages = 3;

en une fonction compliquée uniquement pour utiliser le mot :

function

Nous créons une fonction lorsqu’elle organise réellement une logique compréhensible.

31. Tester une autre valeur sans modifier la fonction

Pour vérifier la réutilisation,

remplacez temporairement :

$pagesConvertiesPhp = 1;

par :

$pagesConvertiesPhp = 3;

Les variables calculées deviennent notamment :

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

Nous appelons pourtant exactement la même fonction.

Elle renvoie cette fois :

La conversion PHP du site est terminée.

32. Tester le troisième état

Testez temporairement :

$pagesConvertiesPhp = 0;

Nous obtenons :

$conversionTerminee = false;
$conversionEnCours = false;

La fonction choisit le bloc :

else

et renvoie :

La conversion PHP du site n’a pas encore commencé.

33. Revenir à l’état réel

Après les tests, remettez :

$pagesConvertiesPhp = 1;

Le fil rouge doit toujours représenter :

index.php
= première page engagée dans PHP

apropos.html
= encore en HTML

contact.html
= encore en HTML

La fonction ne doit pas servir à falsifier l’état du projet.

34. Comprendre le rôle local des paramètres

Dans la fonction :

function construireMessageConversion($conversionTerminee, $conversionEnCours, $pagesRestantes)

les paramètres servent au travail interne de la fonction.

Nous les alimentons avec les arguments de l’appel.

La fonction n’a donc pas besoin d’aller chercher directement toutes les variables du fichier.

Cette manière de travailler rend les dépendances plus visibles.

35. Une fonction peut être appelée plusieurs fois

Nous pourrions écrire plusieurs appels avec des valeurs différentes pour faire des tests.

Par exemple, uniquement pour comprendre :

$testDebut = construireMessageConversion(false, false, 3);
$testCours = construireMessageConversion(false, true, 2);
$testFin = construireMessageConversion(true, false, 0);

Ces trois appels utilisent la même fonction.

Ils produisent trois résultats différents selon leurs arguments.

Supprimez ensuite ces variables de test.

Nous ne les conservons pas dans le projet final.

36. Pourquoi ne pas conserver les appels de test ?

Le projet réel possède déjà ses propres valeurs :

$conversionTerminee
$conversionEnCours
$pagesRestantes

Les appels avec :

false
true
0
2
3

servent uniquement à vérifier le fonctionnement de la fonction.

Nous revenons ensuite aux données réelles.

37. État final du début de index.php

À la fin de cette leçon, le début du fichier peut maintenant contenir :

<?php
function construireMessageConversion($conversionTerminee, $conversionEnCours, $pagesRestantes)
{
    if ($conversionTerminee)
    {
        $message = 'La conversion PHP du site est terminée.';
    }
    elseif ($conversionEnCours)
    {
        $message = 'La conversion PHP du site est en cours : ' . $pagesRestantes . ' pages restent à faire évoluer.';
    }
    else
    {
        $message = 'La conversion PHP du site n’a pas encore commencé.';
    }

    return $message;
}

$nomSite = 'Mon premier site HTML';

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

$nombrePages = 3;
$pagesConvertiesPhp = 1;
$pagesRestantes = $nombrePages - $pagesConvertiesPhp;
$messageAccueil = 'Le site possède ' . $nombrePages . ' pages principales et il reste ' . $pagesRestantes . ' pages à faire évoluer vers PHP.';

$progressionCommencee = $pagesConvertiesPhp > 0;
$conversionTerminee = $pagesRestantes === 0;
$conversionEnCours = $progressionCommencee && !$conversionTerminee;

$messageConversion = construireMessageConversion(
    $conversionTerminee,
    $conversionEnCours,
    $pagesRestantes
);

$formulaireTraite = false;
$formulaireEnAttente = $formulaireTraite === false;

$dernierMessage = null;
$aucunMessage = $dernierMessage === null;

$conversionAContinuer = !$conversionTerminee;
$contactAConfigurer = $formulaireEnAttente && $aucunMessage;
$projetAEncoreDesEtapes = $conversionAContinuer || $contactAConfigurer;

if ($projetAEncoreDesEtapes)
{
    $messageEtatProjet = 'Le projet comporte encore des étapes à terminer.';
}
else
{
    $messageEtatProjet = 'Les étapes prévues pour cette phase du projet sont terminées.';
}
?>

La navigation reste en

foreach

.

Les messages continuent à être affichés dans le HTML comme auparavant.

38. Ce que la fonction a réellement amélioré

Avant :

le déroulement principal contenait directement toute la décision du message

Maintenant :

la fonction contient la logique

le déroulement principal appelle la fonction

$messageConversion reçoit le résultat

Nous avons donc commencé à organiser notre code en responsabilités plus claires.

39. Les fonctions fournies par PHP deviendront importantes dans la dernière leçon

Nous avons déjà rencontré :

var_dump()

comme fonction fournie par PHP.

Dans la dernière leçon, nous rencontrerons d’autres outils déjà fournis par PHP.

Nous expliquerons chacun avant de l’utiliser.

Le fait d’avoir compris :

- l’appel d’une fonction ;
- les arguments ;
- la valeur renvoyée ;

nous permettra de les aborder plus facilement.

40. Préparer la dernière leçon

Notre fichier :

contact.html

possède depuis le cours HTML un vrai formulaire accessible avec notamment :

nom
email
telephone
contact-prefere
message
copie

Jusqu’à présent, PHP ne reçoit toujours pas réellement ces données.

Dans la prochaine leçon, qui sera la dernière du cours, nous allons faire évoluer cette partie du fil rouge.

Nous apprendrons progressivement :

- comment faire traiter le formulaire par PHP ;
- ce que signifie envoyer des données avec POST ;
- comment récupérer les valeurs reçues ;
- pourquoi une donnée reçue doit être vérifiée côté serveur ;
- comment afficher une erreur compréhensible ;
- comment réafficher une valeur textuelle de manière sûre ;
- comment conserver la structure HTML accessible du formulaire.

Nous n’utiliserons pas de base de données.

Nous n’ajouterons pas de session.

Nous resterons dans le périmètre d’un premier cours PHP.

41. La dernière leçon réutilisera les notions déjà apprises

Le traitement du formulaire nous permettra de réunir :

variables
tableaux
conditions
fonctions
valeurs booléennes
HTML accessible

Nous n’introduirons donc pas un nouveau grand chapitre technique.

Nous utiliserons les bases apprises pour produire un résultat concret.

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

Vous devez maintenant être capable d’expliquer :

- ce qu’est une fonction ;
- la différence entre une fonction fournie par PHP et une fonction créée dans le projet ;
- le rôle du mot

function

;
- pourquoi nous avons choisi le nom

construireMessageConversion

;
- ce qu’est un paramètre ;
- pourquoi notre fonction possède trois paramètres ;
- ce qu’est un argument ;
- la différence entre paramètre et argument ;
- pourquoi l’ordre des arguments compte ;
- le rôle de

return

;
- la différence entre

return

et

echo

;
- comment récupérer la valeur renvoyée dans

$messageConversion

;
- pourquoi nous avons supprimé l’ancien bloc de décision à son ancien emplacement ;
- pourquoi la navigation reste en

foreach

;
- pourquoi une fonction doit représenter un rôle compréhensible ;
- pourquoi nous ne créons pas une fonction pour chaque ligne.

Retenez surtout ceci :

function nomFonction($parametre)
{
    ...
    return $resultat;
}

$valeur = nomFonction($argument);

paramètre
= valeur attendue par la fonction

argument
= valeur fournie lors de l’appel

return
= valeur renvoyée par la fonction

Dans la prochaine leçon, nous utiliserons ces bases pour traiter le formulaire de contact côté serveur, valider les données essentielles, préserver son accessibilité et terminer le cours PHP.

Nous partons d’une logique déjà connue :

if ($conversionTerminee)
{
    $messageConversion = 'La conversion PHP du site est terminée.';
}
elseif ($conversionEnCours)
{
    $messageConversion = 'La conversion PHP du site est en cours : ' . $pagesRestantes . ' pages restent à faire évoluer.';
}
else
{
    $messageConversion = 'La conversion PHP du site n’a pas encore commencé.';
}

Nous la regroupons dans :

function construireMessageConversion($conversionTerminee, $conversionEnCours, $pagesRestantes)
{
    if ($conversionTerminee)
    {
        $message = 'La conversion PHP du site est terminée.';
    }
    elseif ($conversionEnCours)
    {
        $message = 'La conversion PHP du site est en cours : ' . $pagesRestantes . ' pages restent à faire évoluer.';
    }
    else
    {
        $message = 'La conversion PHP du site n’a pas encore commencé.';
    }

    return $message;
}

Puis nous appelons la fonction :

$messageConversion = construireMessageConversion(
    $conversionTerminee,
    $conversionEnCours,
    $pagesRestantes
);

Le HTML continue simplement à utiliser :

<p><?php echo $messageConversion; ?></p>

La manière de produire la valeur a changé.

La structure HTML, elle, reste identique.

Continuez dans le même fichier :

index.php

1. Conserver l’état réel du fil rouge

Vérifiez notamment :

$pagesConvertiesPhp = 1;
$pagesRestantes = 2;
$conversionTerminee = false;
$conversionEnCours = true;

2. Déclarer la fonction

Au début du bloc PHP, ajoutez :

function construireMessageConversion($conversionTerminee, $conversionEnCours, $pagesRestantes)
{
}

3. Déplacer la logique connue dans la fonction

Ajoutez à l’intérieur le

if / elseif / else

qui choisit le message.

Utilisez une variable interne :

$message

4. Renvoyer le résultat

Après la condition, ajoutez :

return $message;

5. Remplacer l’ancien bloc principal

À l’endroit où l’ancien

if / elseif / else

construisait

$messageConversion

, utilisez :

$messageConversion = construireMessageConversion(
    $conversionTerminee,
    $conversionEnCours,
    $pagesRestantes
);

6. Vérifier le résultat réel

Avec :

$pagesConvertiesPhp = 1;

le message doit rester :

La conversion PHP du site est en cours : 2 pages restent à faire évoluer.

7. Tester les trois états

Testez temporairement :

$pagesConvertiesPhp = 0;
$pagesConvertiesPhp = 1;
$pagesConvertiesPhp = 3;

une valeur à la fois.

Vérifiez que la même fonction produit trois messages cohérents.

8. Revenir à la valeur réelle

Conservez finalement :

$pagesConvertiesPhp = 1;

9. Nettoyer les tests

Aucun appel de démonstration supplémentaire ne doit rester.

Conservez uniquement l’appel réel qui attribue la valeur à :

$messageConversion

10. Expliquer ce que vous avez fait

Sans regarder la correction, expliquez avec vos propres mots :

1. ce qu’est une fonction ;
2. le rôle du mot

function

;
3. ce qu’est un paramètre ;
4. ce qu’est un argument ;
5. pourquoi l’ordre des arguments compte ;
6. le rôle de

return

;
7. la différence entre

return

et

echo

;
8. pourquoi le HTML n’a pas eu besoin de changer ;
9. pourquoi cette fonction prépare la dernière leçon sur le formulaire.

Dans cette leçon, nous avons créé notre première fonction PHP.

Nous avons appris :

function
= déclarer une fonction

Nous avons créé :

construireMessageConversion

avec trois paramètres :

$conversionTerminee
$conversionEnCours
$pagesRestantes

Nous avons distingué :

paramètre
= variable prévue dans la déclaration

argument
= valeur fournie lors de l’appel

Nous avons également découvert :

return

qui permet à la fonction de renvoyer une valeur.

Nous pouvons maintenant écrire :

$messageConversion = construireMessageConversion(
    $conversionTerminee,
    $conversionEnCours,
    $pagesRestantes
);

Le résultat est toujours affiché avec :

<p><?php echo $messageConversion; ?></p>

Le fil rouge reste donc cohérent :

fonction
= organiser la logique

return
= rendre le résultat

variable
= récupérer le résultat

HTML
= structurer l’affichage

Cette leçon est l’avant-dernière du cours.

Dans la prochaine et dernière leçon, nous ferons évoluer le formulaire de contact pour qu’il soit traité côté serveur, avec validation simple, affichage sûr des données et conservation de la structure accessible.