Les fonctions PHP : les comprendre et les utiliser dans votre code

Une fonction est un bloc de code nommé qui effectue une tâche spécifique. Les fonctions sont l'un des éléments les plus importants en PHP : elles vous permettent d'écrire une logique une seule fois et de la réutiliser partout, plutôt que de copier le même code à de nombreux endroits. Cette page explique comment définir et appeler des fonctions, comment passer des arguments (y compris les valeurs par défaut, les déclarations de type, les passages par référence et les listes d'arguments de longueur variable), comment fonctionnent les valeurs de retour, et les règles de portée qui déterminent quelles variables une fonction peut voir.

Qu'est-ce qu'une fonction PHP ?

Une fonction PHP est un bloc de code réutilisable qui s'exécute uniquement lorsque vous l'appelez. Vous déclarez une fonction avec le mot-clé function, suivi d'un nom, d'une paire de parenthèses listant les éventuels paramètres (les entrées que la fonction accepte), et d'un corps encadré par { }. Une fonction peut éventuellement renvoyer une valeur grâce au mot-clé return.

La forme générale d'une fonction ressemble à ceci :

function functionName($parameter1, $parameter2) {
    // code to run when the function is called
    return $result; // optional
}

Quelques règles de nommage : un nom de fonction doit commencer par une lettre ou un underscore, peut contenir des lettres, des chiffres et des underscores, et est insensible à la casse (sayHello() et SayHello() appellent la même fonction). Par convention, la plupart du code PHP moderne utilise le camelCase ou le snake_case pour les fonctions définies par l'utilisateur.

Pourquoi utiliser des fonctions PHP ?

L'utilisation de fonctions présente plusieurs avantages concrets :

Réutilisabilité. Écrivez la logique une fois, appelez-la autant de fois que nécessaire. Modifier le comportement signifie éditer un seul endroit plutôt que de chercher chaque copie.
Lisibilité. Une fonction bien nommée (calculateTax()) indique au lecteur ce qui se passe sans qu'il ait à lire comment.
Modularité. Décomposer une tâche complexe en fonctions plus petites rend chaque partie plus facile à comprendre, tester et déboguer.
Moins de bugs. Moins de code dupliqué signifie moins d'endroits où la même erreur peut se cacher.

Comment définir et appeler une fonction

Définir une fonction ne fait rien en soi — le corps ne s'exécute que lorsque vous l'appelez en écrivant son nom suivi de parenthèses. L'exemple ci-dessous définit une fonction sans paramètre et l'appelle deux fois.

<?php

function greet() {
    echo "Hello from a function!\n";
}

greet(); // call it
greet(); // call it again

?>

Résultat :

Hello from a function!
Hello from a function!

Fonction simple qui retourne une valeur

Une fonction qui ne prend aucun paramètre et retourne une chaîne :

php— editable, runs on the server

Résultat : Hello, World!

Paramètres et arguments de fonction

Un paramètre est la variable nommée dans la définition de la fonction ; un argument est la valeur réelle que vous passez lors de l'appel. PHP vous offre plusieurs façons de travailler avec eux.

Passage d'arguments

La fonction suivante prend deux paramètres et retourne leur somme. Nous passons 5 et 10 comme arguments.

php— editable, runs on the server

Résultat : 15

Valeurs de paramètre par défaut

Un paramètre peut avoir une valeur par défaut, utilisée lorsque l'appelant omet cet argument. Les paramètres avec des valeurs par défaut doivent venir après les paramètres obligatoires.

<?php

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

echo greet("Anna") . "\n";          // uses the default greeting
echo greet("Anna", "Welcome");      // overrides the default

?>

Résultat :

Hello, Anna!
Welcome, Anna!

Déclarations de type

Vous pouvez déclarer le type attendu de chaque paramètre et de la valeur de retour. Cela rend une fonction autodocumentée et permet à PHP de générer une erreur lorsqu'il reçoit le mauvais type.

<?php

function multiply(int $a, int $b): int {
    return $a * $b;
}

echo multiply(4, 3);

?>

Résultat : 12

Passage d'arguments par référence

Par défaut, PHP passe les arguments par valeur — la fonction travaille sur une copie, et la variable originale reste inchangée. Préfixez un paramètre avec & pour le passer par référence, permettant à la fonction de modifier directement la variable de l'appelant.

<?php

function addOne(&$number) {
    $number++;
}

$count = 10;
addOne($count);
echo $count;

?>

Résultat : 11

Listes d'arguments de longueur variable

Lorsque vous ne savez pas combien d'arguments seront passés, l'opérateur ... (splat) les collecte tous dans un tableau.

<?php

function sumAll(...$numbers) {
    return array_sum($numbers);
}

echo sumAll(1, 2, 3, 4, 5);

?>

Résultat : 15

Valeurs de retour

Une fonction retourne une valeur avec le mot-clé return. return arrête également la fonction immédiatement — tout code qui suit est ignoré. Une fonction sans return (ou return; sans valeur) retourne null. Pour retourner plusieurs valeurs à la fois, retournez un tableau (ou un list() peut le décomposer côté réception).

<?php

function minMax($a, $b) {
    if ($a < $b) {
        return [$a, $b]; // returns and exits here
    }
    return [$b, $a];
}

[$min, $max] = minMax(8, 3);
echo "Min: $min, Max: $max";

?>

Résultat : Min: 3, Max: 8

Pour un examen plus approfondi, consultez le chapitre sur l'instruction return PHP.

Portée des variables

Les variables créées à l'intérieur d'une fonction sont locales à cette fonction — elles n'existent pas en dehors d'elle, et la fonction ne peut pas voir les variables définies dans la portée environnante (globale) à moins de les importer avec le mot-clé global ou de les passer comme arguments.

<?php

$message = "outside";

function showScope() {
    // $message from the global scope is NOT visible here
    $message = "inside";
    echo $message;
}

showScope();        // prints the local value
echo "\n";
echo $message;      // prints the global value, untouched

?>

Résultat :

inside
outside

La portée est une source fréquente de confusion pour les débutants — le chapitre sur la portée des variables PHP explique en détail global, static et les variables locales. Consultez également le chapitre sur les Variables PHP pour les bases.

Erreurs courantes à éviter

Appeler une fonction avant qu'elle retourne ce que vous attendez — rappellez-vous que return ne fait que renvoyer une valeur ; vous devez encore l'echoer ou la stocker. add(5, 10); seul ne produit rien de visible.
Placer un paramètre par défaut avant un paramètre obligatoire — PHP exige que les valeurs par défaut viennent en dernier.
Attendre que les modifications se propagent à l'extérieur — sans &, modifier un paramètre à l'intérieur d'une fonction ne change pas la variable de l'appelant.
Re-déclarer un nom de fonction — vous ne pouvez pas définir deux fonctions avec le même nom ; PHP génère une erreur fatale.

Conclusion

Les fonctions PHP sont le fondement d'un code organisé et réutilisable. Une fois à l'aise pour définir des fonctions, passer des arguments (avec des valeurs par défaut, des types, des références et des variadiques), retourner des valeurs et raisonner sur la portée, vous pouvez décomposer n'importe quel grand problème en morceaux propres et testables. Ensuite, explorez l'utilisation des tableaux PHP et des chaînes PHP, sur lesquels les fonctions opèrent fréquemment.

Pratique

Quelles sont les caractéristiques clés des fonctions en PHP ?

Les fonctions en PHP ne sont pas des morceaux de code réutilisables.En PHP, les fonctions effectuent des actions et peuvent retourner des valeurs.Créer une fonction en PHP ne nécessite aucun nommage et elle ne peut accepter aucun paramètre ou argument.La même fonction peut être appelée plus d'une fois dans un script PHP.En PHP, il n'est pas possible de fournir des valeurs par défaut aux paramètres de fonction.