Par valeur (défaut)
La fonction reçoit une copie : modifier son paramètre ne change rien chez l'appelant.1
Informatique · PHP
Calculer une moyenne, trier des élèves, vérifier un mot de passe : on écrit ces traitements une fois, dans des fonctions, et on range les données dans des tableaux.
Déjà à l'aise ? Aller au quizLe principe
Une fonction range un traitement sous un nom. Un tableau range plusieurs valeurs sous des clés. Les deux vont presque toujours ensemble.
Les données entrent, la fonction calcule, un résultat sort.
Après cette fiche, tu sais
password_hash() pour les mots de passe.Le plan
En JavaScript, oui. Et en PHP ?
Écrire une fois, servir partout
Notion 1 · Fonctions
Une fonction reçoit des paramètres, annonce leur type et celui de sa valeur de retour, puis renvoie un résultat avec return, qui termine aussitôt la fonction.1
Vocabulaire
Le paramètre est la variable déclarée. L'argument est la valeur passée à l'appel. Ici, la liste [5, 4.5, 3.5] est copiée dans $notes.
Valeur par défaut
$seuil = 4.0 rend le paramètre facultatif : on peut l'omettre à l'appel. Les paramètres facultatifs se placent après les obligatoires.1
Deux fonctions
Une fonction peut en appeler une autre. mention() reçoit le résultat de moyenne() et choisit le mot.
<?php
function moyenne(array $notes): float
{
return round(array_sum($notes) / count($notes), 2);
}
function mention(float $m, float $seuil = 4.0): string
{
return $m >= $seuil ? 'suffisant' : 'insuffisant';
}
Les appels
<?php echo moyenne([5, 4.5, 3.5]), "\n"; echo mention(moyenne([5, 4.5, 3.5])), "\n"; echo mention(3.9), "\n"; echo mention(seuil: 3.5, m: 3.9), "\n"; // arguments nommés
4.33 suffisant insuffisant suffisant
Les arguments nommés (PHP 8.0 et plus) se passent par leur nom, dans n'importe quel ordre.1
Fais défiler : pour exécuter echo mention(moyenne([5, 4.5, 3.5]));, PHP empile un cadre par fonction appelée, puis le retire quand elle renvoie sa valeur.
Le script démarre
Types
Par défaut, PHP convertit une valeur vers le type attendu : la chaîne '5' devient l'entier 5. Avec declare(strict_types=1); en tête de fichier, seule une valeur du bon type est acceptée. Un int reste accepté là où un float est attendu.1
Le même appel, deux modes
<?php
declare(strict_types=1);
function double(int $n): int
{
return $n * 2;
}
Ici, double('5') est refusé. On attrape l'erreur avec try pour la montrer.
<?php
echo double(5), "\n";
try {
echo double('5');
} catch (TypeError $e) {
echo "TypeError attrapée\n";
}
10 TypeError attrapée
Piège
echo au lieu de return. Une fonction qui affiche son résultat avec echo ne le renvoie pas : elle renvoie null, impossible à réutiliser. Une fonction calcule et renvoie ; c'est l'appelant qui décide d'afficher.1
Cinq lignes mélangées : la définition, puis un appel qui affiche le résultat.
Ce qu'une fonction voit
Notion 2 · Portée
Une variable utilisée dans une fonction est locale : les variables du script ne sont pas visibles à l'intérieur. En JavaScript ou en C, une fonction lit les variables extérieures ; en PHP, non.2
Une variable du script, invisible
<?php
$taux = 0.081; // TVA suisse, taux normal
function ttc(float $prix): float
{
return round($prix * (1 + $taux), 2); // $taux n'existe pas ici
}
echo ttc(100);
Warning: Undefined variable $taux 100
PHP prévient, puis calcule avec null : 100 × (1 + 0) = 100. Un prix faux, sans erreur bloquante.2
La correction
Deux solutions : passer le taux en paramètre, ou écrire une fonction fléchée qui capture $taux.
<?php
$taux = 0.081;
function ttc(float $prix, float $taux): float
{
return round($prix * (1 + $taux), 2);
}
echo ttc(100, $taux), "\n";
$ttcFleche = fn(float $prix) => round($prix * (1 + $taux), 2);
echo $ttcFleche(100), "\n";
108.1 108.1
Par référence
<?php
function bonus(array &$notes): void // & : par référence
{
$notes[] = 6;
}
$a = [5, 4];
bonus($a);
echo count($a);
3
Fais défiler : une correction, puis ce qui se passe quand une fonction reçoit une valeur ou une référence.
Le script a sa variable $taux, la fonction a son paramètre $prix. Dans ttc(), $taux n'existe pas : Warning, puis un résultat faux.2
La bonne correction : faire de $taux un paramètre. À l'appel, sa valeur est copiée dans la fonction. Le mot-clé global marcherait aussi, mais cache une dépendance.2
Un tableau passé à une fonction est lui aussi copié : la fonction ajoute un 6 à sa copie. Chez l'appelant, $a compte toujours 2 notes.1
Avec & devant le paramètre, la fonction travaille sur le tableau de l'appelant lui-même : après l'appel, $a compte 3 notes.1
Une fonction fléchée fn capture automatiquement les variables du script dont elle se sert, par valeur : $taux est visible, sans paramètre.1
Quatre façons de passer ou de garder une valeur.
La fonction reçoit une copie : modifier son paramètre ne change rien chez l'appelant.1
La fonction modifie la variable de l'appelant. À réserver aux cas où c'est le but, et à annoncer dans le nom.1
Une variable static reste locale, mais garde sa valeur d'un appel à l'autre : utile pour un compteur.2
fn($x) => expression : une petite fonction sans nom, qui capture par valeur les variables extérieures qu'elle utilise.1
Quatre fonctions courtes, toutes exécutées avec PHP 8.4.
Des valeurs rangées sous des clés
Notion 3 · Tableaux
Un tableau PHP est une table ordonnée qui associe des valeurs à des clés, entières ou textuelles.3 Sans clés écrites, ['pomme', 'poire'] numérote à partir de 0.
Ajouter, retirer
<?php $fruits = ['pomme', 'poire', 'kiwi']; $fruits[] = 'figue'; // clé 3 unset($fruits[1]); // retire 'poire' : clés 0, 2, 3 $fruits[] = 'mangue'; // clé 4, pas 1
Avec $t[] = …, PHP prend la plus grande clé entière déjà utilisée, plus 1. Et unset() retire un élément sans renuméroter les autres.36
<?php print_r($fruits); echo count($fruits), "\n";
Array
(
[0] => pomme
[2] => kiwi
[3] => figue
[4] => mangue
)
4
Renuméroter
<?php $fruits = array_values($fruits); // clés 0 à 3 print_r($fruits);
Array
(
[0] => pomme
[1] => kiwi
[2] => figue
[3] => mangue
)
Fais défiler : les instructions ci-dessus, une par une, avec les clés au-dessus des cases.
Trois fruits
Piège
for et count sur un tableau troué. Après unset($fruits[1]), une boucle for ($i = 0; $i < count($fruits); $i++) lit la clé 1, qui n'existe plus (Warning: Undefined array key 1), et n'atteint jamais la dernière case. Pour parcourir un tableau, foreach suit les clés réelles.3
Quatre petits tableaux, testés avec PHP 8.4.
Des clés qui ont un nom
Notion 4 · Tableaux associatifs
Avec 'cle' => valeur, on choisit soi-même les clés. Un tableau associatif décrit une chose par ses propriétés, et peut en contenir d'autres.3
Une élève et ses notes
<?php
$eleve = [
'prenom' => 'Zoé',
'classe' => '2M3',
'notes' => [6, 5.5],
];
echo $eleve['prenom'], "\n";
$eleve['email'] = 'zoe@example.com'; // nouvelle clé
Zoé
On parcourt ensuite le tableau avec foreach, qui donne la clé et la valeur de chaque entrée.
<?php
foreach ($eleve as $cle => $valeur) {
if (is_array($valeur)) {
$valeur = implode(', ', $valeur);
}
echo "$cle : $valeur\n";
}
prenom : Zoé classe : 2M3 notes : 6, 5.5 email : zoe@example.com
Une clé existe-t-elle ?
Deux outils, qui diffèrent quand la valeur vaut null :3
<?php
$eleve = ['prenom' => 'Zoé', 'remarque' => null];
var_dump(isset($eleve['remarque'])); // la valeur est null
var_dump(array_key_exists('remarque', $eleve)); // la clé existe
echo $eleve['email'] ?? "pas d'adresse"; // clé absente
bool(false) bool(true) pas d'adresse
Isset ou array_key_exists
Piège
Lire une clé absente. echo $eleve['email']; sans vérification affiche Warning: Undefined array key "email". Une saisie de formulaire peut toujours manquer : on lit avec ??.
Une liste d'élèves est un tableau de tableaux associatifs : on écrit $eleves[0]['prenom'] pour lire le prénom du premier élève.
Des fonctions pour les listes
Notion 5 · Fonctions natives
PHP fournit des dizaines de fonctions pour les tableaux. Pour chacune, deux questions : modifie-t-elle le tableau ou en renvoie-t-elle un nouveau ? Garde-t-elle les clés ?
| Fonction | Ce qu'elle fait | Clés |
|---|---|---|
sort($t) | trie sur place, renvoie true | renumérotées |
usort($t, $f) | trie sur place selon une fonction de comparaison | renumérotées |
array_filter($t, $f) | renvoie les éléments pour lesquels $f répond vrai | gardées, avec des trous |
array_map($f, $t) | renvoie $f appliquée à chaque élément | gardées (un seul tableau) |
array_values($t) | renvoie les valeurs | renumérotées dès 0 |
in_array($v, $t) | la valeur est-elle présente ? (avec ==) | sans objet |
Sources des comportements : la documentation de chaque fonction.3 Exemple avec des prix en CHF et la TVA suisse de 8,1 % :5
<?php $prix = ['cahier' => 12.5, 'stylo' => 3.2, 'sac' => 48.0]; $ttc = array_map(fn($p) => round($p * 1.081, 2), $prix); print_r($ttc);
Array
(
[cahier] => 13.51
[stylo] => 3.46
[sac] => 51.89
)
Filtrer
<?php $notes = [5, 3.5, 6, 4, 2.5]; $suffisantes = array_filter($notes, fn($n) => $n >= 4); print_r($suffisantes);
Array
(
[0] => 5
[2] => 6
[3] => 4
)
Pour retrouver chaque note à sa place, non ?
array_values().Fais défiler : les notes passent par array_filter, array_values, sort, puis implode. Surveille les clés.
Cinq notes
Piège
$t = sort($t); sort() trie le tableau qu'on lui donne et renvoie true. Écrire $t = sort($t); remplace le tableau trié par… true.3
in_array compare avec ==. in_array('1e1', ['10']) répond true, car les deux chaînes numériques valent 10. Un troisième argument true impose === : in_array('1e1', ['10'], true) répond false.38
Dix opérations courantes. Range chacune selon ce qu'elle fait au tableau $t.
Ne jamais stocker en clair
Notion 6 · Mots de passe
Un mot de passe ne se stocke jamais en clair, ni chiffré : on garde son empreinte, calculée par une fonction à sens unique.4
L'empreinte inclut un sel aléatoire : deux mots de passe identiques donnent deux empreintes différentes. Elle est lente à calculer, pour freiner les essais en masse.4 En PHP, password_hash() fait tout cela ; password_verify() vérifie une saisie.47
Créer et vérifier
<?php
$hash = password_hash('Chat-Violet-42!', PASSWORD_DEFAULT);
echo strlen($hash), "\n"; // 60 caractères (bcrypt)
echo substr($hash, 0, 7), "\n"; // algorithme et coût
var_dump(password_verify('Chat-Violet-42!', $hash));
var_dump(password_verify('chat-violet-42!', $hash)); // une majuscule de moins
var_dump($hash === password_hash('Chat-Violet-42!', PASSWORD_DEFAULT));
Sortie obtenue avec PHP 8.4. La dernière ligne est fausse : deux appels donnent deux sels différents, donc deux empreintes différentes.
60 $2y$12$ bool(true) bool(false) bool(false)
Fais défiler : une vraie empreinte bcrypt, produite par PHP 8.4, se sépare en quatre morceaux, puis sert à vérifier deux saisies.
60 caractères
Piège
md5() et sha1(). Ces fonctions sont rapides et sans sel : un attaquant qui vole la base peut tester des milliards de mots de passe, et deux comptes au même mot de passe ont la même empreinte. L'OWASP les écarte pour les mots de passe.4
Et Argon2id ?
L'OWASP place Argon2id en tête de ses recommandations, puis scrypt ; bcrypt reste acceptable pour les systèmes existants. Si PHP est compilé avec Argon2, password_hash($mdp, PASSWORD_ARGON2ID) l'utilise. password_verify() lit l'algorithme dans l'empreinte et marche avec les deux.4
password_hash() à l'inscription, password_verify() à la connexion. Jamais de comparaison d'empreintes à la main.Ce que contient une empreinte, morceau par morceau.
Aujourd'hui bcrypt ; la constante peut changer dans une future version. On stocke l'empreinte dans une colonne de 255 caractères.4
Le nombre qui suit $2y$ est le logarithme en base 2 du nombre de tours. Ici, $2y$12$ donne 212 = 4096 tours.4
Tiré au hasard à chaque appel ; ne jamais fournir le sien. Il est rangé dans l'empreinte, avec l'algorithme et le coût.4
bcrypt ne tient compte que des 72 premiers octets du mot de passe.4
Les bons réflexes
Habitudes de pro
À relire avant chaque fonction que tu écris.
Une fonction fait une seule tâche, avec un nom en verbe : calculerMoyenne, verifierNote.
Typer les paramètres et le retour, envisager declare(strict_types=1);, et renvoyer avec return plutôt qu'afficher avec echo.
Passer en paramètre ce dont la fonction a besoin, plutôt que d'utiliser global.
Parcourir les tableaux avec foreach, et renuméroter avec array_values() si les clés comptent.
Lire une clé qui peut manquer avec ??, et chercher avec in_array(…, true).
password_hash() et password_verify(), rien d'autre.
Tous les corrigés ont été exécutés avec PHP 8.4.
compterInsuffisantes(array $notes): int qui compte les notes inférieures à 4.Voir le corrigé<?php
function compterInsuffisantes(array $notes): int
{
$n = 0;
foreach ($notes as $note) {
if ($note < 4) {
$n++;
}
}
return $n;
}
echo compterInsuffisantes([5, 3.5, 6, 3, 4]), "\n";
echo count(array_filter([5, 3.5, 6, 3, 4], fn($x) => $x < 4));
2 2
La seconde ligne obtient le même résultat avec array_filter puis count. Le 4 n'est pas compté : il est suffisant.
<?php
$eleves = [
['prenom' => 'Léa', 'moyenne' => 5.25],
['prenom' => 'Noah', 'moyenne' => 3.75],
['prenom' => 'Zoé', 'moyenne' => 5.75],
];
usort($eleves, fn($a, $b) => $b['moyenne'] <=> $a['moyenne']);
foreach ($eleves as $rang => $e) {
echo ($rang + 1) . '. ' . $e['prenom'] . ' (' . $e['moyenne'] . ")\n";
}
1. Zoé (5.75) 2. Léa (5.25) 3. Noah (3.75)
usort trie avec une fonction qui compare deux éléments ; <=> renvoie le nombre négatif, nul ou positif attendu. En écrivant $b avant $a, on trie dans l'ordre décroissant.3
<?php
$taux = 0.081;
function prixTTC($prix)
{
echo round($prix * (1 + $taux), 2);
}
$total = prixTTC(10) + prixTTC(20);
echo "\nTotal : $total";
Warning: Undefined variable $taux 10 Warning: Undefined variable $taux 20 Total : 0
1) $taux n'est pas visible dans la fonction. 2) La fonction affiche au lieu de renvoyer : elle renvoie null, et null + null donne 0. Version corrigée :
<?php
function prixTTC(float $prix, float $taux = 0.081): float
{
return round($prix * (1 + $taux), 2);
}
$total = prixTTC(10) + prixTTC(20);
echo "Total : $total";
Total : 32.43
Tout tenir en huit lignes
À retenir
function nom(type $p = défaut): type { return …; }. Sans return, elle renvoie null.declare(strict_types=1) exige le bon type, sinon TypeError.fn les capture par valeur.& devant le paramètre pour modifier la variable de l'appelant.$t[] = x prend la plus grande clé entière utilisée + 1 ; unset() ne renumérote pas ; array_values() si besoin.'cle' => valeur ; isset est faux pour une valeur null, array_key_exists non.sort trie sur place et renvoie true ; array_filter garde les clés ; in_array(…, true) pour ===.password_hash() à l'inscription, password_verify() à la connexion ; colonne de 255 caractères.Douze questions pour finir
Fiche relue et sourcée en septembre 2026, refaite en récit en octobre 2026. Tout le code a été exécuté avec PHP 8.4.