Fonctions en PHP ⚙️

Les fonctions sont les briques fondamentales de tout programme. En PHP, elles permettent d'organiser, réutiliser et rendre ton code plus lisible.

Syntaxe de base

<?php
// Fonction simple
function direBonjour($nom) {
    return "Bonjour, $nom !";
}

echo direBonjour("Alice"); // Bonjour, Alice !

// Fonction sans paramètre
function getHeure() {
    return date("H:i");
}

echo getHeure(); // 14:30 (selon l'heure actuelle)
?>

Paramètres et valeurs par défaut

<?php
// Paramètres avec valeurs par défaut
function saluer($nom, $politesse = "Monsieur") {
    return "Bonjour $politesse $nom";
}

echo saluer("Dupont");           // Bonjour Monsieur Dupont
echo saluer("Marie", "Madame"); // Bonjour Madame Marie

// Paramètres typés (PHP 7+)
function addition(int $a, int $b): int {
    return $a + $b;
}

echo addition(3, 5);     // 8
echo addition(3.7, 2.2); // 5 (truncation vers int)
?>

💡 Astuce : Les paramètres typés assurent que les bons types sont passés. C'est un premier niveau de validation.

Paramètres par référence

<?php
// Par défaut, PHP passe par copie (valeur)
function modifierCopie($x) {
    $x = 100;
}

$val = 5;
modifierCopie($val);
echo $val; // 5 (inchangé !)

// Pour modifier la variable originale, on passe par référence avec &
function modifierReference(&$x) {
    $x = 100;
}

modifierReference($val);
echo $val; // 100 (modifié !)
?>

Fonctions avec types de retour

<?php
// Type de retour simple
function multiplier(float $a, float $b): float {
    return $a * $b;
}

// Retour nullable (PHP 7.1+)
function chercher(int $id): ?string {
    $noms = [1 => "Alice", 2 => "Bob"];
    return $noms[$id] ?? null;
}

// Retour void (PHP 7.1+)
function afficher(string $texte): void {
    echo $texte;
    // Pas de return nécessaire
}

// Retour union type (PHP 8.0+)
function calculer(string $type, int $val): int|float {
    return match($type) {
        "entier" => (int)$val,
        "decimal" => (float)$val,
        default => 0
    };
}
?>

Fonctions anonymes (Closures)

<?php
// Fonction anonyme classique
$doubler = function($x) {
    return $x * 2;
};

echo $doubler(5); // 10

// Closures avec variables du contexte (use)
$seuil = 100;
$verifier = function($montage) use ($seuil) {
    return $montage >= $seuil;
};

echo $verifier(150) ? "Approuvé" : "Refusé"; // Approuvé
?>

Les arrays comme fonctions (Callbacks)

<?php
$fruits = ["pomme", "banane", "cerise", "datte"];

// array_map : applique une fonction à chaque élément
$majuscules = array_map(function($f) {
    return strtoupper($f);
}, $fruits);
// ["POMME", "BANANE", "CERISE", "DATTE"]

// array_filter : filtre les éléments
$longs = array_filter($fruits, function($f) {
    return strlen($f) > 5;
});
// ["banane", "cerise", "datte"]

// array_reduce : réduit à une seule valeur
$total = array_reduce([1, 2, 3, 4, 5], function($acc, $val) {
    return $acc + $val;
}, 0);
// 15

// Fonction fléchée (PHP 7.4+)
$triple = fn($x) => $x * 3;
echo $triple(4); // 12
?>

Arguments variables

<?php
// ... (opérateur splat)
function somme(int ...$nombres): int {
    return array_sum($nombres);
}

echo somme(1, 2, 3, 4, 5); // 15
echo somme(10, 20);          // 30

// func_get_args() — méthode traditionnelle
function dixArgs() {
    $args = func_get_args();
    return count($args) . " arguments reçus";
}

echo dixArgs(1, 2, 3); // 3 arguments reçus
?>

Récursivité

<?php
// Factorielle
function factorielle(int $n): int {
    if ($n <= 1) return 1;
    return $n * factorielle($n - 1);
}

echo factorielle(5); // 120

// Fibonacci
function fibonacci(int $n): int {
    if ($n <= 0) return 0;
    if ($n === 1) return 1;
    return fibonacci($n - 1) + fibonacci($n - 2);
}

echo fibonacci(10); // 55
?>

Variables superglobales

<?php
// Ces variables sont toujours disponibles en PHP
echo $_GET['nom'];     // Paramètres URL ?nom=...
echo $_POST['email'];  // Données formulaires POST
echo $_COOKIE['id'];   // Cookies
echo $_SERVER['REMOTE_ADDR']; // Adresse IP du client
echo $_SESSION['user']; // Variable de session

// Vérification avant utilisation
$nom = $_GET['nom'] ?? "Anonyme";
?>

Comparaison avec JavaScript

Exercice pratique

Crée une bibliothèque de fonctions utilitaires :

<?php
// Fonction qui valide un email
function validerEmail(string $email): bool {
    return filter_var($email, FILTER_VALIDATE_EMAIL) !== false;
}

// Fonction qui formate un nombre
function formaterNombre(float $nb, int $decimales = 2): string {
    return number_format($nb, $decimales, ",", " ");
}

// Fonction qui génère un ID unique
function genererId(int $longueur = 8): string {
    return bin2hex(random_bytes($longueur / 2));
}

// Tests
echo validerEmail("test@example.com") ? "Valide" : "Invalide"; // Valide
echo formaterNombre(1234.5678);     // 1 234,57
echo genererId();                    // ex: "a3f2b1c8"
?>

🎯 A retenir : Les fonctions rendent ton code modulaire et réutilisable. Utilise les types de retour pour la clarté, les valeurs par défaut pour la flexibilité, et les closures pour les callbacks.

---

Prochaine leçon : Les tableaux en PHP — manipule les collections de données !