Après les boucles, on sait répéter un bloc. Une fonction, c’est répéter sans recopier le code : on l’écrit une fois, on l’appelle avec des valeurs différentes.
Paramètres, return, typage, valeurs par défaut, et à la fin les arguments nommés (PHP 8). Comme dans la vidéo.
Pourquoi une fonction ?
« Bonjour Thibault », « Bonjour Marie », « Bonjour Jean » : trois fois le même echo, seule la variable change. Pas factorisé.
Une fonction : un nom, un bloc, éventuellement des paramètres. On appelle, PHP exécute le bloc.
Référence : fonctions définies par l’utilisateur.
Déclarer et appeler
Mot-clé function, un nom sans dollar, des parenthèses, le corps entre accolades.
<?php
function sayHello()
{
echo 'Bonjour';
}
sayHello();
sayHello();
sayHello();
Trois appels, trois « Bonjour ». Le code entre accolades s’exécute à chaque appel.
Un paramètre, puis plusieurs
Le prénom change. On déclare un paramètre : une variable qui n’existe que dans la fonction.
<?php
function sayHello($firstName)
{
echo "Bonjour $firstName !";
}
sayHello('Thibault');
sayHello('Marie');
sayHello('Jean');
La valeur passée à l’appel est associée au paramètre.
Plusieurs paramètres : virgule. Autant qu’il en faut.
Référence : paramètres et arguments.
<?php
function introduce($firstName, $age)
{
echo "Je m'appelle $firstName et j'ai $age ans";
}
introduce('Thibault', 30);
return : renvoyer une valeur (et s’arrêter)
Une fonction peut afficher (echo) ou retourner une valeur. Tout dépend de la logique.
Référence : valeurs de retour. return termine la fonction tout de suite et rend la main à l’appelant. Sans return, PHP renvoie null.
<?php
function calculatePrice($unitPrice, $quantity)
{
return $unitPrice * $quantity;
}
$total = calculatePrice(20, 3);
echo $total; // 60
On peut assigner le résultat à une variable, parce que la fonction renvoie 60, elle ne l’affiche pas.
return coupe le reste, un peu comme break dans une boucle. Dès qu’on a la valeur, inutile de continuer :
<?php
function getAgeMessage($age)
{
if ($age < 18) {
return 'Tu es mineur';
}
return 'Tu es majeur';
}
$message = getAgeMessage(16);
echo $message; // Tu es mineur
Avec 16, on retourne au premier return : le second n’est pas exécuté. Utile pour des vérifications en tête de fonction (return tôt, le reste après).
Typer les paramètres et le retour
Oui, on type les paramètres d’une fonction (la signature), et le retour : après les parenthèses, : puis le type. Union : | (PHP 8). Mauvais type → TypeError.
<?php
function calculatePrice(float $unitPrice, int $quantity): float
{
return $unitPrice * $quantity;
}
Prix unitaire : float (1,5 €). Quantité : int (pas une moitié de bonbon). Retour : float.
On reprend le typage vu plus tôt : paramètres et retour, pas les variables locales.
Valeurs par défaut
Un paramètre peut avoir une valeur si on ne le passe pas. Syntaxe d’affectation dans la signature.
<?php
function greet(string $name, string $language = 'fr'): string
{
if ($language === 'en') {
return "Hello $name !";
}
return "Bonjour $name !";
}
echo greet('Thibault'); // Bonjour Thibault ! (fr par défaut)
echo greet('Thibault', 'en'); // Hello Thibault !
Neuf fois sur dix en français : on ne répète pas 'fr'. Si on passe 'en', le défaut est ignoré.
Plusieurs défauts, tous typés :
<?php
function createUser(
string $name,
string $email,
bool $isAdmin = false,
bool $isActive = true,
string $language = 'fr',
) {
// ...
}
Les optionnels viennent après les obligatoires, sinon on ne peut pas les omettre. C’est la règle officielle.
Arguments nommés (PHP 8)
Sans rien faire, les arguments sont positionnels : l’ordre de la signature. Pour ne toucher que $language, il faudrait quand même passer $isAdmin et $isActive (même à leur défaut). Lourd.
Depuis PHP 8.0, les arguments nommés : nomDuParametre: valeur. On ne passe que ce qu’on veut. Les autres gardent leur défaut. L’ordre n’a plus d’importance.
<?php
createUser(
name: 'Thibault',
email: 'thibault@example.com',
language: 'en',
);
Pas besoin de false et true au milieu. Lisibilité, et on saute les optionnels.
Une fonction peut en appeler une autre
Oui. Tout code PHP valide peut être dans une fonction, y compris un autre appel.
<?php
function calculateVat(float $price): float
{
return $price * 0.20;
}
function priceIncludingTax(float $price): float
{
return $price + calculateVat($price);
}
Démo vidéo
FAQ rapide (SEO & technique)
Comment déclarer une fonction ?
function + nom sans dollar + parenthèses + accolades. Voir fonctions utilisateur.
echo ou return ?
echo affiche. return renvoie une valeur et arrête la fonction. Voir valeurs de retour.
Peut-on typer ?
Oui : paramètres et retour (: float). Union avec |. Mauvais type → TypeError. Voir déclarations de type.
À quoi sert une valeur par défaut ?
Si l’argument n’est pas passé, PHP utilise le défaut. Les optionnels après les obligatoires. Voir arguments.
Arguments nommés ?
PHP 8 : parametre: valeur. Plus besoin de l’ordre, on omet les défauts.
Conclusion
Une fonction : function, un nom, des parenthèses. Autant de paramètres qu’il faut (virgule), typés, avec défaut si besoin. return renvoie et coupe. Le retour se type aussi (:). Depuis PHP 8, les arguments nommés évitent l’ordre et les défauts recopiés.
La playlist continue. Abonnez-vous à la chaîne YouTube pour l’épisode suivant.
