Informatique · PHP

Fonctions et tableaux en 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 quiz

Le principe

Une fonction range un traitement sous un nom. Un tableau range plusieurs valeurs sous des clés. Les deux vont presque toujours ensemble.

5 4,5 3,5 0 1 2 tableau fonction moyenne() 4,33 une liste entre, un nombre sort

Les données entrent, la fonction calcule, un résultat sort.

Après cette fiche, tu sais

  • déclarer une fonction avec des paramètres typés, des valeurs par défaut et un type de retour ;
  • prévoir ce qu'une fonction voit (la portée) et ce qu'elle modifie (valeur ou référence) ;
  • créer, parcourir et modifier des tableaux indexés et associatifs sans perdre une clé ;
  • employer les fonctions natives des tableaux, et password_hash() pour les mots de passe.
Une variable créée en dehors d'une fonction : la fonction peut-elle la lire directement ?

En JavaScript, oui. Et en PHP ?

Réponse dans la notion 2. Garde ta supposition en tête.

Écrire une fois, servir partout

Notion 1 · Fonctions

Paramètres, types et return

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

function moyenne(array $notes): float type paramètre type de retour Une valeur impossible à convertir déclenche une TypeError.

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.

argument [5, 4.5, 3.5] paramètre $notes la valeur est copiée dans la variable de la fonction

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

La pile d'appels

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.

Scène 1 · Pile d'appels

Le script démarre

pile d'appels le sommet s'exécute

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

double('5') sans declare 10 double('5') avec strict_types TypeError

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

Exercice · remettre dans l'ordre

Reconstruis la fonction moyenne

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

Ce qu'une fonction voit, ce qu'elle modifie

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

script $taux = 0.081 ttc() $prix $taux ? la fonction ne voit que ses paramètres

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

$taux = null → 0 100 × 1 = 100 un résultat faux, sans erreur bloquante

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
deux noms, un seul tableau $a $notes [5, 4, 6]

La portée, pas à pas

Fais défiler : une correction, puis ce qui se passe quand une fonction reçoit une valeur ou une référence.

script (portée globale)
Étape 1 sur 5 · deux mondes

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

Étape 2 sur 5 · le passer en argument

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

Étape 3 sur 5 · un tableau copié

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

Étape 4 sur 5 · par référence

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

Étape 5 sur 5 · fonction fléchée

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

Réponse à ma question : non. En PHP, une fonction ne voit que ses paramètres et ses variables locales. Si elle a besoin d'une valeur, on la lui passe en argument.

Retenir

Quatre façons de passer ou de garder une valeur.

Par valeur (défaut)

La fonction reçoit une copie : modifier son paramètre ne change rien chez l'appelant.1

Par référence (&)

La fonction modifie la variable de l'appelant. À réserver aux cas où c'est le but, et à annoncer dans le nom.1

static

Une variable static reste locale, mais garde sa valeur d'un appel à l'autre : utile pour un compteur.2

fn (fonction fléchée)

fn($x) => expression : une petite fonction sans nom, qui capture par valeur les variables extérieures qu'elle utilise.1

Exercice · à toi

Que va afficher ce code ?

Quatre fonctions courtes, toutes exécutées avec PHP 8.4.

Des valeurs rangées sous des clés

Notion 3 · Tableaux

Des valeurs rangées sous des clés

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.

$fruits pomme clé 0 poire clé 1 kiwi clé 2 chaque case a une clé, et une seule

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
)
avant pomme clé 0 retirée clé 1 ? kiwi clé 2 figue clé 3 mangue clé 4 après array_values pomme kiwi figue mangue

Le trou que unset() laisse

Fais défiler : les instructions ci-dessus, une par une, avec les clés au-dessus des cases.

Scène 2 · Tableau en mémoire

Trois fruits

$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

Exercice · prévoir

Quelle clé ?

Quatre petits tableaux, testés avec PHP 8.4.

Des clés qui ont un nom

Notion 4 · Tableaux associatifs

Des clés qui ont un nom

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

'prenom' 'Zoé' 'classe' '2M3' 'notes' [6, 5.5]

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

cas isset array_key_exists clé absente false false clé présente, valeur null false true clé présente, valeur 'Zoé' true true
  • isset($t['k']) : vrai si la clé existe et que sa valeur n'est pas null.3
  • array_key_exists('k', $t) : vrai dès que la clé existe, même avec la valeur null.3
  • $t['k'] ?? défaut : la valeur si elle existe et n'est pas null, sinon la valeur par défaut, sans avertissement.

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.

$eleves[0] ['prenom'] 'Zoé' d'abord l'élève, puis le champ, puis la valeur

Des fonctions pour les listes

Notion 5 · Fonctions natives

Trier, filtrer, transformer

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 ?

$t sort($t) même tableau, trié $t array_map($f, $t) nouveau tableau, $t inchangé modifie ou renvoie : la question à se poser
FonctionCe qu'elle faitClés
sort($t)trie sur place, renvoie truerenumérotées
usort($t, $f)trie sur place selon une fonction de comparaisonrenumérotées
array_filter($t, $f)renvoie les éléments pour lesquels $f répond vraigardées, avec des trous
array_map($f, $t)renvoie $f appliquée à chaque élémentgardées (un seul tableau)
array_values($t)renvoie les valeursrenumé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
)
5 3,5 6 4 2,5 clé 0 clé 1 clé 2 clé 3 clé 4 5 6 4
Pourquoi array_filter garde-t-il les clés ?

Pour retrouver chaque note à sa place, non ?

Exactement. Si tu veux renuméroter, ajoute array_values().

Une chaîne de traitements

Fais défiler : les notes passent par array_filter, array_values, sort, puis implode. Surveille les clés.

Scène 3 · Fonctions natives

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

$t = sort($t); true le tableau trié disparaît : $t ne vaut plus qu'un booléen

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

Exercice · classer

Modifie le tableau, ou en renvoie un nouveau ?

Dix opérations courantes. Range chacune selon ce qu'elle fait au tableau $t.

Ne jamais stocker en clair

Notion 6 · Mots de passe

Une fonction native qui protège : password_hash()

Un mot de passe ne se stocke jamais en clair, ni chiffré : on garde son empreinte, calculée par une fonction à sens unique.4

mot de passe Chat-Violet-42! password_hash empreinte 60 caractères à sens unique, avec un sel et un coût

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)
Chat-Violet-42! chat-violet-42! password_verify true false

L'empreinte éclatée

Fais défiler : une vraie empreinte bcrypt, produite par PHP 8.4, se sépare en quatre morceaux, puis sert à vérifier deux saisies.

Scène 4 · Empreinte bcrypt

60 caractères

password_verify(

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

Anna : motdepasse Ben : motdepasse md5 même empreinte sans sel, un même mot de passe donne toujours la même empreinte

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

Retiens les deux gestes : password_hash() à l'inscription, password_verify() à la connexion. Jamais de comparaison d'empreintes à la main.

Retenir

Ce que contient une empreinte, morceau par morceau.

PASSWORD_DEFAULT

Aujourd'hui bcrypt ; la constante peut changer dans une future version. On stocke l'empreinte dans une colonne de 255 caractères.4

Coût

Le nombre qui suit $2y$ est le logarithme en base 2 du nombre de tours. Ici, $2y$12$ donne 212 = 4096 tours.4

Sel

Tiré au hasard à chaque appel ; ne jamais fournir le sien. Il est rangé dans l'empreinte, avec l'algorithme et le coût.4

72 octets

bcrypt ne tient compte que des 72 premiers octets du mot de passe.4

Les bons réflexes

Habitudes de pro

Six réflexes à garder

À relire avant chaque fonction que tu écris.

Une tâche, un nom

Une fonction fait une seule tâche, avec un nom en verbe : calculerMoyenne, verifierNote.

Typer et renvoyer

Typer les paramètres et le retour, envisager declare(strict_types=1);, et renvoyer avec return plutôt qu'afficher avec echo.

Pas de global

Passer en paramètre ce dont la fonction a besoin, plutôt que d'utiliser global.

foreach

Parcourir les tableaux avec foreach, et renuméroter avec array_values() si les clés comptent.

Lire sans risque

Lire une clé qui peut manquer avec ??, et chercher avec in_array(…, true).

Mots de passe

password_hash() et password_verify(), rien d'autre.

Entraînement

Trois exercices corrigés

Tous les corrigés ont été exécutés avec PHP 8.4.

1Écris une fonction 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.

2Trie une liste d'élèves de la meilleure à la moins bonne moyenne, et affiche le classement.Voir le corrigé
<?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

3Ce code devrait afficher « Total : 32.43 ». Il affiche autre chose : trouve les deux erreurs.Voir le corrigé
<?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

La fiche en huit lignes

  • Fonction : function nom(type $p = défaut): type { return …; }. Sans return, elle renvoie null.
  • Types : convertis par défaut ; declare(strict_types=1) exige le bon type, sinon TypeError.
  • Portée : une fonction ne voit pas les variables du script : on les passe en argument ; fn les capture par valeur.
  • Arguments : copiés par défaut ; & devant le paramètre pour modifier la variable de l'appelant.
  • Clés : $t[] = x prend la plus grande clé entière utilisée + 1 ; unset() ne renumérote pas ; array_values() si besoin.
  • Associatifs : 'cle' => valeur ; isset est faux pour une valeur null, array_key_exists non.
  • Natives : sort trie sur place et renvoie true ; array_filter garde les clés ; in_array(…, true) pour ===.
  • Mots de passe : password_hash() à l'inscription, password_verify() à la connexion ; colonne de 255 caractères.

Douze questions pour finir

Dernière étape : le quiz. Douze questions tirées au hasard, différentes à chaque partie. Si tu te trompes, lis bien l'explication.
Quiz final

Teste-toi

Sources

  1. The PHP Group, PHP Manual : « Function parameters and arguments » (par valeur, par référence, valeurs par défaut, arguments nommés), « Returning values », « Arrow Functions », « Type declarations » (strict_types). arguments, return, fonctions fléchées, types (php.net), consulté le 8 octobre 2026.
  2. The PHP Group, PHP Manual : « Variable scope » (portée locale, global, static). php.net, consulté le 8 octobre 2026.
  3. The PHP Group, PHP Manual : « Arrays » (clés, ajout, unset), et les fonctions array_filter, array_map, sort, usort, in_array, array_key_exists. tableaux, array_filter, array_map, sort, usort, in_array, array_key_exists (php.net), consulté le 8 octobre 2026.
  4. The PHP Group, PHP Manual : « password_hash », « Password hashing constants », « crypt » (format CRYPT_BLOWFISH) ; OWASP, Password Storage Cheat Sheet. password_hash, constantes, crypt (php.net), OWASP, consulté le 8 octobre 2026.
  5. Administration fédérale des contributions (AFC), Taux de TVA applicables en Suisse : taux normal de 8,1 % depuis le 1er janvier 2024. estv.admin.ch, consulté le 8 octobre 2026.
  6. The PHP Group, PHP Manual : « unset » (suppression d'une variable ou d'un élément de tableau). unset (php.net), consulté le 8 octobre 2026.
  7. The PHP Group, PHP Manual : « password_verify » (vérifie une saisie contre une empreinte). password_verify (php.net), consulté le 8 octobre 2026.
  8. The PHP Group, PHP Manual : « Comparison Operators » (== et ===, comparaison des chaînes numériques). opérateurs de comparaison (php.net), consulté le 8 octobre 2026.

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.

Glisser pour continuer vers La POO en PHP
Gymnase 2