1.4Fonctions & portée des variables
L'essentiel en 30 secondes
- Fonction = entrées → traitement → sortie : function nom($params) { return ... } — paramètres explicites, résultat renvoyé.
- Portée locale, pas de globales : une variable interne est invisible dehors (et inversement) — on passe tout en paramètres.
- Typer en PHP moderne : function f(int $a): int (+ strict_types) — documente, détecte les erreurs, rend robuste.
Mini-cas filé — Riad factorise ses devis à Constantine
Riad calcule le prix TTC à trois endroits de son site avec le même copier-coller — et quand le taux change, il oublie un endroit : un devis sur trois est faux. Il crée une fonction prixTTC($ht, $taux = 0.19) typée, qui reçoit tout en paramètres et renvoie le résultat : un seul endroit à corriger. Il constate au passage qu'une variable $total définie dans la fonction n'existe pas dehors — la portée locale l'oblige à renvoyer proprement. Les trois devis redeviennent justes d'un coup.
Suite du cas 1.1-1.3 — Riad passe de la répétition à la réutilisation.
1. Définir et appeler une fonction
Une fonction est un bloc de code RÉUTILISABLE. On la définit avec function et on l'appelle par son nom : function saluer($nom) { return 'Bonjour ' . $nom; } puis saluer('Alice'). Les paramètres sont les entrées ; le return renvoie la sortie. On peut avoir des paramètres par défaut ($nom = 'inconnu'). Les fonctions évitent la duplication, améliorent la lisibilité, la maintenance et le test.
Riad remplace ses trois copier-coller de calcul TTC par un appel à prixTTC(10000) : le taux par défaut s'applique, et un cas particulier passe son propre taux.
2. Portée & typage
Portée (scope) : une variable définie DANS une fonction est locale (invisible dehors) ; une variable externe n'est pas accessible dedans. Isolation voulue — on passe les données en paramètres (pas via des globales). PHP moderne encourage le typage : function additionner(int $a, int $b): int documente, attrape des erreurs, rend robuste. À connaître aussi : closures (fonctions anonymes) et les centaines de fonctions natives — ne pas réinventer, consulter la doc.
Riad type sa fonction en (float $ht, float $taux = 0.19): float avec declare(strict_types=1) : un mauvais type lève une erreur claire au lieu d'un devis silencieusement faux.
🔎 Exemple concret — 🔎 Exemple concret — Une fonction typée
Entrées et sortie claires, comme Riad pour ses devis.
declare(strict_types=1);
function prixTTC(float $ht, float $taux = 0.20): float {
return $ht * (1 + $taux);
}
echo prixTTC(100); // 120
echo prixTTC(100, 0.055); // 105.5Lecture : paramètres typés, défaut pour le taux courant, retour typé — l'interface se lit sans ouvrir le corps.
Leçon : declare(strict_types=1) pour un typage rigoureux — une fonction réutilisable et auto-documentée.
Vocabulaire de la section
- Fonction
- Bloc de code réutilisable accomplissant une tâche : function saluer($nom) { return ... }, appelée par son nom. Évite la duplication, améliore lisibilité et maintenance.
Exemple simple : Le prixTTC($ht, $taux) unique de Riad, appelé trois fois.
Ce que ce n'est pas : le même calcul copié-collé à trois endroits.
Réflexe : calcul répété deux fois = fonction.
- Paramètres / retour
- Paramètres : données passées en entrée (avec valeurs par défaut possibles). Retour (via return) : le résultat renvoyé. Les entrées et sorties de la fonction.
Exemple simple : Le $ht et le $taux de Riad, et le TTC renvoyé.
Ce que ce n'est pas : lire une globale et modifier une variable externe.
Réflexe : tout entre par paramètres, tout sort par return.
- Portée (scope)
- Une variable définie dans une fonction est LOCALE (invisible dehors) ; une variable externe n'est pas accessible dans la fonction. Isolation voulue — passer les données en PARAMÈTRES.
Exemple simple : Le $total interne de Riad, invisible depuis l'extérieur.
Ce que ce n'est pas : accéder à une globale via le mot-clé global.
Réflexe : besoin d'une donnée ? paramètre, pas globale.
- Typage des paramètres/retour
- Déclarer les types (function f(int $a): int) documente, attrape des erreurs et rend le code robuste — fortement recommandé en PHP moderne.
Exemple simple : Le (float $ht, float $taux): float de Riad.
Ce que ce n'est pas : un prix passé en texte qui fausse le devis en silence.
Réflexe : typer paramètres et retour, activer le strict.
- Closures / fonctions natives
- Fonctions anonymes (closures) et fléchées : sans nom, stockables/passables (callbacks). PHP a des centaines de fonctions natives (strlen, array_map…) — consulter la doc.
Exemple simple : Riad qui trie avec usort et une fléchée au lieu de coder son tri.
Ce que ce n'est pas : réécrire à la main une fonction native existante.
Réflexe : chercher la native avant de coder.
En pratique — En pratique — Écrire des fonctions réutilisables
- Définissez une fonction avec `function`, des paramètres et un `return` (ex. calculer un prix TTC à partir d'un prix HT).
- Ajoutez un paramètre par défaut et testez l'appel avec et sans ce paramètre.
- Constatez la portée : une variable définie dans la fonction n'existe pas dehors ; passez les données externes en PARAMÈTRES (pas via des globales).
- Ajoutez le typage des paramètres et du retour (`function f(int $a, int $b): int`) et découvrez quelques fonctions natives (strlen, count, array_map).
Script prêt à dire — refuser la globale en revue de code (30 s)
« Je propose qu'on passe cette donnée en paramètre plutôt qu'en globale : la signature dira ce que la fonction attend, elle restera prévisible et testable. Les globales créent des dépendances cachées — le prochain bug viendra de là. »
À dire en revue de code ; montrer la signature avant/après.
Modèle copier-coller — fonction typée prixTTC (paramètres + défaut + return)
Devis à Constantine
Comme Riad : une seule fonction prixTTC typée — le jour où le taux change, une ligne à corriger, trois devis justes.
Donnée externe à utiliser
La passer en paramètre explicite : la signature documente le besoin, la fonction reste testable isolément.
Valeur par défaut
Le taux courant en défaut ($taux = 0.19) : l'appel simple couvre le cas courant, l'appel complet le cas particulier.
Tri ou transformation
Une closure ou fléchée pour usort/array_map : le traitement ponctuel tient en une ligne, sans fonction nommée dédiée.
✓ Bonnes pratiques
- Passer les données en paramètres et retourner le résultat (pas de globales).
- Typer les paramètres et le retour (declare(strict_types=1)).
- Chercher une fonction native avant de coder à la main.
✗ Pièges fréquents
- Utiliser des variables globales (dépendances cachées, effets de bord).
- Écrire une fonction géante à responsabilités multiples.
- Réinventer une fonction native existante.
Points clés à retenir
- Les FONCTIONS sont des blocs réutilisables (PARAMÈTRES en entrée, RETURN en sortie) : évitent la duplication, améliorent lisibilité, maintenance et test.
- PORTÉE : une variable définie dans une fonction est LOCALE ; les variables externes ne sont pas accessibles dedans (isolation) — passer les données en PARAMÈTRES.
- PHP moderne : TYPER les paramètres et le retour (`function f(int $a): int`) documente, attrape des erreurs, rend robuste.
- Closures pour les callbacks ; des CENTAINES de fonctions NATIVES — consulter la doc, ne pas réinventer. Bien découper = code maintenable.
Défi 48h — appliquez demain
Extrayez un calcul dupliqué de votre code en fonction typée (modèle ci-dessus) : paramètres explicites, return, strict_types. Appelez-la aux anciens endroits et vérifiez les résultats. 25 minutes suffisent.
- Je définis des fonctions avec paramètres, défaut, return et types.
- Je respecte la portée locale — aucune globale.
- Je cherche la fonction native avant de coder à la main.
Questions fréquentes
Pourquoi passer les données en paramètres plutôt qu'en variables globales ?
En PHP, une variable définie dans une fonction est locale, et une variable externe n'y est pas accessible (isolation voulue). On POURRAIT utiliser le mot-clé `global`, mais c'est une mauvaise pratique : couplage caché (rien dans la signature n'indique la dépendance), effets de bord imprévisibles (modifications à distance), difficulté à TESTER, réutilisation limitée. Passer en PARAMÈTRES donne : interface EXPLICITE, prévisibilité (mêmes entrées = même résultat), testabilité, découplage. Pour la config partagée, utilisez des approches propres (injection de dépendances, services) plutôt que des globales.
Faut-il typer les paramètres et retours en PHP, et qu'est-ce que cela apporte ?
Oui, fortement recommandé en PHP moderne. Le typage apporte : (1) détection d'ERREURS — un mauvais type lève une erreur claire au point d'appel (surtout en strict) ; (2) DOCUMENTATION implicite — les types décrivent l'interface sans lire le corps ; (3) meilleur OUTILLAGE — autocomplétion, analyse statique, refactoring sûr ; (4) ROBUSTESSE. Activez `declare(strict_types=1);` et convertissez explicitement au besoin. Coût minime, bénéfices importants.
Comment une fonction doit-elle recevoir les données dont elle a besoin ?