Leçon 4/8 7 min

Fonctions et boucles

Créez des blocs de code réutilisables avec les fonctions PHP, les boucles for/foreach et les fonctions natives.

Déclarer une fonction

Une fonction est un bloc de code réutilisable. Au lieu de répéter le même code, tu l'appelles par son nom :

function saluer($nom) {
    return "Bonjour, $nom !";
}

echo saluer("Alice");  // → Bonjour, Alice !
echo saluer("Bob");    // → Bonjour, Bob !

Anatomie :

  • function : le mot-clé pour déclarer
  • $nom : le paramètre (l'entrée)
  • return : la valeur renvoyée (la sortie)

Paramètres et valeurs par défaut

function calculerPrix($prix, $tva = 0.20) {
    return $prix * (1 + $tva);
}

echo calculerPrix(100);        // → 120 (TVA par défaut : 20%)
echo calculerPrix(100, 0.055); // → 105.5 (TVA réduite : 5.5%)

Le paramètre $tva a une valeur par défaut de 0.20. Si on ne le passe pas, PHP utilise cette valeur.

Typer ses fonctions (dès le début)

Par défaut, une fonction PHP accepte n'importe quoi : calculerPrix("cent") ne plante pas tout de suite, et te renvoie un résultat absurde. Pour éviter ça, on peut typer les paramètres et la valeur de retour. Autant prendre l'habitude tout de suite.

Prédisez avant de lire

La fonction carre est déclarée ainsi : function carre(int $n) { return $n * $n; }. On l'appelle avec une chaîne : carre("4"). Avant de dérouler : PHP lève-t-il une erreur, ou renvoie-t-il quand même un résultat ? Et qu'est-ce qui changerait si on ajoutait declare(strict_types=1); tout en haut du fichier ?

Voir la réponse

Par défaut, PHP est en mode coercitif : il convertit automatiquement la chaîne numérique "4" en entier 4, donc carre("4") renvoie 16 sans erreur. Avec declare(strict_types=1); en tête de fichier, PHP passe en mode strict : il refuse la conversion et lève une TypeError, car "4" n'est pas un int. Bonne pratique : activer strict_types=1 pour que les types déclarés soient réellement garantis et que les erreurs soient détectées tôt. Attention : une chaîne non numérique comme "abc" lève une TypeError même en mode coercitif.

// On précise le TYPE de chaque paramètre, et le type de retour (après les « : »)
function calculerPrix(float $prix, float $tva = 0.20): float {
    return $prix * (1 + $tva);
}

calculerPrix(100, 0.055);   // OK
calculerPrix("cent");       // TypeError : PHP refuse, au lieu de calculer n'importe quoi

Les types de base : int, float, string, bool, array, le nom d'une classe, ou void (ne renvoie rien). On autorise null avec un ? (?string), et on combine avec une union (int|string, PHP 8).

Type tes fonctions dès que tu les écris. Le code se documente tout seul (on voit ce qui entre et ce qui sort) et PHP attrape les erreurs de type au lieu de produire un résultat faux en silence. Pour aller plus loin, mets declare(strict_types=1); tout en haut du fichier : PHP devient strict et ne convertit plus un "5" en 5 dans ton dos.

Fonctions natives utiles

PHP a des centaines de fonctions intégrées. Voici les plus courantes :

On n'apprend pas ces fonctions par cœur. Personne ne connaît les centaines de fonctions PHP de tête. Le vrai réflexe du développeur : quand tu as besoin de faire quelque chose (« couper une chaîne », « trier un tableau »), tu cherches : sur la doc officielle php.net, via une recherche web, ou en demandant à l'IA « existe-t-il une fonction PHP qui fait X ? ». Puis tu lis sa doc : ce qu'elle prend en entrée, ce qu'elle renvoie. Savoir chercher et comprendre vaut bien mieux que mémoriser, c'est ça le métier.

// Chaînes
echo strlen("Bonjour");            // → 7 (longueur)
echo strtolower("ALICE");          // → alice
echo strtoupper("alice");          // → ALICE
echo str_replace("monde", "PHP", "Bonjour monde"); // → Bonjour PHP
echo trim("  hello  ");           // → "hello" (supprime espaces)
echo substr("Bonjour", 0, 3);     // → Bon

// Nombres
echo number_format(1234567.89, 2, ',', ' '); // → 1 234 567,89
echo round(3.7);   // → 4
echo ceil(3.2);    // → 4
echo floor(3.9);   // → 3

// Date
echo date("d/m/Y");        // → 27/05/2026
echo date("H:i");          // → 14:30
echo date("l");            // → Tuesday

Boucles : for, while, foreach

// for : quand on connaît le nombre d'itérations
for ($i = 1; $i <= 5; $i++) {
    echo "<p>Ligne $i</p>";
}

// while : tant qu'une condition est vraie
$compteur = 0;
while ($compteur < 3) {
    echo $compteur . " ";
    $compteur++;
}
// → 0 1 2

// foreach : pour parcourir un tableau (le plus utilisé)
$langages = ["PHP", "JavaScript", "Python"];
foreach ($langages as $langage) {
    echo "<li>$langage</li>";
}

// foreach avec clé et valeur
$prix = ["pain" => 1.20, "lait" => 0.95];
foreach ($prix as $produit => $montant) {
    echo "$produit : {$montant}€ <br>";
}

L'expression match (PHP 8)

PHP 8 a introduit match, une alternative plus élégante au switch :

$status = "published";

$label = match($status) {
    'draft'     => 'Brouillon',
    'published' => 'Publié',
    'archived'  => 'Archivé',
    default     => 'Inconnu',
};

echo $label;  // → Publié

Avantages de match : pas de break nécessaire, comparaison stricte (===), et c'est une expression (on peut l'assigner à une variable).

À vous d'essayer

Modifiez la fonction ou la boucle, puis exécutez :

<?php
function calculerPrix($prix, $tva = 0.20) {
    return $prix * (1 + $tva);
}

$produits = ["Pain" => 1.20, "Lait" => 0.95, "Beurre" => 2.30];

foreach ($produits as $nom => $ht) {
    $ttc = calculerPrix($ht);
    echo "$nom : " . number_format($ttc, 2) . " EUR TTC\n";
}
?>

Declaring a function

A function is a reusable code block. Instead of repeating the same code, you call it by name:

function greet($name) {
    return "Hello, $name!";
}

echo greet("Alice");  // → Hello, Alice!
echo greet("Bob");    // → Hello, Bob!

Anatomy:

  • function — the keyword to declare
  • $name — the parameter (input)
  • return — the returned value (output)

Parameters and default values

function calculatePrice($price, $vat = 0.20) {
    return $price * (1 + $vat);
}

echo calculatePrice(100);        // → 120 (default VAT: 20%)
echo calculatePrice(100, 0.055); // → 105.5 (reduced VAT: 5.5%)

The $vat parameter has a default value of 0.20. If not passed, PHP uses this value.

Typing your functions (from the start)

By default, a PHP function accepts anything: calculatePrice("hundred") doesn't crash right away, and returns an absurd result. To avoid that, you can type the parameters and the return value. Might as well build the habit now.

Predict before reading

The function square is declared as: function square(int $n) { return $n * $n; }. It is called with a string: square("4"). Before unfolding: does PHP throw an error, or does it return a result anyway? And what would change if you added declare(strict_types=1); at the very top of the file?

See the answer

By default, PHP is in coercive mode: it automatically converts the numeric string "4" to the integer 4, so square("4") returns 16 with no error. With declare(strict_types=1); at the top of the file, PHP switches to strict mode: it refuses the conversion and throws a TypeError, because "4" is not an int. Best practice: enable strict_types=1 so that declared types are truly enforced and errors are caught early. Note: a non-numeric string like "abc" throws a TypeError even in coercive mode.

// We state the TYPE of each parameter, and the return type (after the ":")
function calculatePrice(float $price, float $vat = 0.20): float {
    return $price * (1 + $vat);
}

calculatePrice(100, 0.055);   // OK
calculatePrice("hundred");    // TypeError: PHP refuses, instead of computing nonsense

The basic types: int, float, string, bool, array, a class name, or void (returns nothing). You allow null with a ? (?string), and combine with a union (int|string, PHP 8).

Type your functions as you write them. The code documents itself (you see what goes in and out) and PHP catches type errors instead of silently producing a wrong result. To go further, add declare(strict_types=1); at the very top of the file: PHP becomes strict and no longer converts a "5" into 5 behind your back.

Useful built-in functions

PHP has hundreds of built-in functions. Here are the most common:

You don't learn these functions by heart. Nobody knows PHP's hundreds of functions from memory. The real developer reflex: when you need to do something ("split a string", "sort an array"), you search — on the official docs php.net, via a web search, or by asking the AI "is there a PHP function that does X?". Then you read its docs: what it takes in, what it returns. Knowing how to search and understand beats memorizing — that's the job.

// Strings
echo strlen("Hello");             // → 5 (length)
echo strtolower("ALICE");         // → alice
echo strtoupper("alice");         // → ALICE
echo str_replace("world", "PHP", "Hello world"); // → Hello PHP
echo trim("  hello  ");          // → "hello" (removes spaces)
echo substr("Hello", 0, 3);      // → Hel

// Numbers
echo number_format(1234567.89, 2, '.', ','); // → 1,234,567.89
echo round(3.7);   // → 4
echo ceil(3.2);    // → 4
echo floor(3.9);   // → 3

// Date
echo date("d/m/Y");        // → 27/05/2026
echo date("H:i");          // → 14:30
echo date("l");            // → Tuesday

Loops: for, while, foreach

// for — when you know the number of iterations
for ($i = 1; $i <= 5; $i++) {
    echo "<p>Line $i</p>";
}

// while — as long as a condition is true
$counter = 0;
while ($counter < 3) {
    echo $counter . " ";
    $counter++;
}
// → 0 1 2

// foreach — to loop through arrays (most used)
$languages = ["PHP", "JavaScript", "Python"];
foreach ($languages as $language) {
    echo "<li>$language</li>";
}

// foreach with key and value
$prices = ["bread" => 1.20, "milk" => 0.95];
foreach ($prices as $product => $amount) {
    echo "$product: \${$amount} <br>";
}

The match expression (PHP 8)

PHP 8 introduced match, a more elegant alternative to switch:

$status = "published";

$label = match($status) {
    'draft'     => 'Draft',
    'published' => 'Published',
    'archived'  => 'Archived',
    default     => 'Unknown',
};

echo $label;  // → Published

Advantages of match: no break needed, strict comparison (===), and it's an expression (you can assign it to a variable).

À vous d'essayer (vrai PHP)

Une fonction (avec une TVA par défaut) et un foreach, exécutés pour de vrai. Change les prix, puis clique sur « Run » :

<?php
function prixTTC($ht, $tva = 0.20) {     // $tva a une valeur par défaut
    return round($ht * (1 + $tva), 2);
}

$produits = [
    "Pain"    => 1.20,
    "Lait"    => 0.95,
    "Beurre"  => 2.30,
    "Fromage" => 3.50,
];

printf("%-10s %8s %8s\n", "Produit", "HT", "TTC");
foreach ($produits as $nom => $ht) {
    printf("%-10s %6.2f € %6.2f €\n", $nom, $ht, prixTTC($ht));
}
?>

🎯 Pratique

S'entraîner (clique pour ouvrir) :

Prompt IA
Avec l'IA

Copiez ce prompt dans Claude ou ChatGPT :

Écris une fonction PHP qui prend un tableau de notes (0 à 20) et renvoie la moyenne, la note la plus haute et la plus basse. Utilise les fonctions natives array_sum, count, min, max.
💬 Ré-explique sans regarder
Ré-explique sans regarder

Sans relire la leçon : avec tes mots, à quoi servent les types dans function calculerPrix(float $prix, float $tva = 0.20): float ? Que se passe-t-il si on appelle calculerPrix("cent") ?

Une bonne explication dit : les float devant $prix et $tva imposent le type des entrées, le : float impose le type de la sortie. Le code se documente tout seul (on voit ce qui entre et ce qui sort). Appeler calculerPrix("cent") lève une TypeError au lieu de calculer un résultat absurde en silence. Bonus : declare(strict_types=1); en haut du fichier empêche PHP de convertir "5" en 5 tout seul.
⚖️ Juge le code de l'IA
Accepter ou rejeter le code de l'IA

Tu lui as demandé une fonction qui transforme un statut en libellé. L'IA propose ce code. Ton rôle de relecteur : l'accepter tel quel ou le rejeter, et dire pourquoi.

function libelle(string $status): string {
    return match($status) {
        'draft'     => 'Brouillon',
        'published' => 'Publié',
    };
}

echo libelle('archived');
À rejeter. Le match n'a pas de branche default et ne couvre pas 'archived' : contrairement au switch, un match non exhaustif lève une UnhandledMatchError à l'exécution. Ici libelle('archived') plante. C'est justement la rigueur de match (comparaison stricte, exhaustivité), mais il faut l'assumer : ajoute default => 'Inconnu',. Le réflexe pro : toujours prévoir le cas non géré.
🧠 Rappel libre
Rappel libre

Sans remonter dans la leçon : dans function calculerPrix($prix, $tva = 0.20), que veut dire = 0.20 ? Et comment parcourir un tableau associatif pour récupérer à la fois la clé et la valeur ?

= 0.20 est une valeur par défaut : si on appelle calculerPrix(100) sans second argument, PHP utilise 0.20 ; on peut quand même la surcharger avec calculerPrix(100, 0.055). Pour parcourir clé et valeur : foreach ($prix as $produit => $montant) { … }$produit est la clé et $montant la valeur.
Comment déclarer une fonction en PHP ?
Quelle boucle est la plus utilisée pour parcourir un tableau en PHP ?
Que renvoie strlen("PHP") ?
Prochaine étape

Vous maîtrisez les fonctions et les boucles, de quoi traiter des données. Reste à les recevoir : on passe aux formulaires, pour capter ce que tape vraiment un visiteur avec GET et POST, et apprendre à ne jamais lui faire confiance les yeux fermés.

Leçon 5 : Formulaires et GET/POST →

Une erreur dans cette leçon, un passage flou, une question ? Écrivez-moi : chaque retour améliore ce cours.

Besoin d'un développeur pour votre projet ?

Réponse sous 24h · Sans engagement