Aller au contenu principal

Module PHP.7 – Fonctions

Objectif​

Maîtriser les fonctions PHP : déclaration, paramètres, valeurs par défaut, retour, et typage des fonctions pour créer du code réutilisable.

Théorie​

Déclaration de fonction​

Structure de base :

function nomFonction() {
    // Code
}

Exemple simple :

function saluer() {
    echo "Bonjour !";
}

saluer();  // Appel de la fonction

Fonction avec paramètres :

function saluer($nom) {
    echo "Bonjour " . $nom;
}

saluer("Jean");  // Bonjour Jean

Fonction avec retour :

function additionner($a, $b) {
    return $a + $b;
}

$resultat = additionner(5, 3);  // 8

Paramètres​

Paramètres obligatoires :

function afficherNom($prenom, $nom) {
    echo "$prenom $nom";
}

afficherNom("Jean", "Dupont");  // OK
afficherNom("Jean");            // Erreur : paramètre manquant

Valeurs par défaut :

function saluer($nom, $langue = "fr") {
    if ($langue == "fr") {
        echo "Bonjour $nom";
    } elseif ($langue == "en") {
        echo "Hello $nom";
    }
}

saluer("Jean");           // Bonjour Jean (langue par défaut)
saluer("Jean", "en");     // Hello Jean

Ordre important : Les paramètres avec valeurs par défaut doivent être en dernier :

// ✅ Correct
function exemple($obligatoire, $optionnel = "défaut") {}

// ❌ Incorrect
function exemple($optionnel = "défaut", $obligatoire) {}

Paramètres nommés (PHP 8.0+) :

function creerPersonne($nom, $age, $ville = "Paris") {
    return [
        "nom" => $nom,
        "age" => $age,
        "ville" => $ville
    ];
}

// Appel avec paramètres nommés
creerPersonne(nom: "Jean", age: 30);
creerPersonne(age: 30, nom: "Jean");  // Ordre n'importe plus

Return​

Retour simple :

function obtenirNom() {
    return "Jean";
}

$nom = obtenirNom();

Retour multiple (via tableau) :

function obtenirInfos() {
    return [
        "nom" => "Jean",
        "age" => 30
    ];
}

$infos = obtenirInfos();
echo $infos["nom"];

Retour conditionnel :

function trouverMaximum($a, $b) {
    if ($a > $b) {
        return $a;
    }
    return $b;
}

Retour null :

function chercher($tableau, $valeur) {
    foreach ($tableau as $item) {
        if ($item == $valeur) {
            return $item;
        }
    }
    return null;  // Non trouvé
}

Typage des fonctions​

Typage des paramètres (PHP 7.0+) :

function additionner(int $a, int $b): int {
    return $a + $b;
}

additionner(5, 3);      // OK
additionner("5", 3);    // Erreur si strict_types=1

Typage du retour :

function obtenirNom(): string {
    return "Jean";
}

function calculer(): float {
    return 3.14;
}

function rien(): void {
    echo "Pas de retour";
}

Types disponibles :

  • Types scalaires : int, float, string, bool
  • array
  • object
  • Classes/interfaces
  • ?type (nullable) : ?string = string ou null
  • void (pas de retour)
  • mixed (PHP 8.0+)

Exemple complet :

declare(strict_types=1);

function calculerMoyenne(array $notes): ?float {
    if (empty($notes)) {
        return null;
    }
    
    $somme = array_sum($notes);
    return $somme / count($notes);
}

$moyenne = calculerMoyenne([15, 18, 12]);  // 15.0
$moyenne = calculerMoyenne([]);            // null

Fonctions variadiques​

Fonctions acceptant un nombre variable d'arguments.

Ancienne méthode :

function somme() {
    $args = func_get_args();
    return array_sum($args);
}

Nouvelle méthode (PHP 5.6+) :

function somme(...$nombres): float {
    return array_sum($nombres);
}

somme(1, 2, 3, 4, 5);  // 15

Avec types :

function additionner(int ...$nombres): int {
    return array_sum($nombres);
}

Fonctions anonymes (closures)​

Fonction anonyme :

$saluer = function($nom) {
    return "Bonjour " . $nom;
};

echo $saluer("Jean");

Arrow functions (PHP 7.4+) :

$additionner = fn($a, $b) => $a + $b;

$resultat = $additionner(5, 3);  // 8

Utilisation avec array_map :

$nombres = [1, 2, 3, 4];
$doubles = array_map(fn($n) => $n * 2, $nombres);
// [2, 4, 6, 8]

Portée des variables​

Variables locales :

function test() {
    $locale = "Je suis locale";
    echo $locale;
}

// $locale n'existe pas ici

Variables globales :

$globale = "Je suis globale";

function test() {
    global $globale;  // Accéder à la variable globale
    echo $globale;
}

Éviter les globales : Préférez passer en paramètre :

$nom = "Jean";

function saluer($nom) {  // Paramètre plutôt que global
    echo "Bonjour " . $nom;
}

saluer($nom);

Static : Variable qui conserve sa valeur entre les appels :

function compteur() {
    static $count = 0;
    $count++;
    return $count;
}

compteur();  // 1
compteur();  // 2
compteur();  // 3

Fonctions récursives​

Une fonction qui s'appelle elle-même.

Exemple : Factorielle

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

factorielle(5);  // 120 (5 * 4 * 3 * 2 * 1)

Attention : Toujours avoir une condition d'arrêt pour éviter la récursion infinie.

Exercice​

  1. Fonctions de base

    • Créez des fonctions simples avec paramètres
    • Testez les appels avec différentes valeurs
    • Utilisez return pour obtenir des résultats

  2. Paramètres par défaut

    • Créez des fonctions avec paramètres optionnels
    • Testez avec et sans les paramètres optionnels
    • Vérifiez l'ordre des paramètres

  3. Typage

    • Créez des fonctions avec typage strict
    • Testez avec les bons et mauvais types
    • Utilisez différents types de retour

  4. Fonctions variadiques

    • Créez une fonction qui accepte plusieurs arguments
    • Testez avec différents nombres d'arguments
    • Utilisez array_sum ou array_product

  5. Fonctions anonymes

    • Créez des closures
    • Utilisez-les avec array_map, array_filter
    • Testez les arrow functions

Quiz​

  1. Comment déclare-t-on une fonction en PHP ?

    • func nom()
    • function nom()
    • def nom()

  2. Où doivent être les paramètres avec valeurs par défaut ?

    • Au début
    • À la fin
    • N'importe où

  3. Que signifie le typage ?string ?

    • String obligatoire
    • String ou null
    • String ou int

  4. Que fait static dans une fonction ?

    • Rend la fonction globale
    • Conserve la valeur entre les appels
    • Rend la fonction constante

  5. Comment créer une fonction variadique ?

    • function test($args)
    • function test(...$args)
    • function test($...args)

Mini défi​

Mission : Créer une bibliothèque de fonctions mathématiques

Créez un ensemble de fonctions réutilisables pour des calculs mathématiques :

Fonctions à créer :

  1. Opérations de base

    • additionner(float ...$nombres): float
    • soustraire(float $a, float $b): float
    • multiplier(float ...$nombres): float
    • diviser(float $a, float $b): ?float (retourne null si division par zéro)

  2. Fonctions avancées

    • puissance(float $base, float $exposant): float
    • racineCarree(float $nombre): ?float (null si négatif)
    • arrondir(float $nombre, int $decimales = 2): float
    • pourcentage(float $valeur, float $pourcent): float

  3. Fonctions sur tableaux

    • moyenne(array $nombres): ?float
    • maximum(array $nombres): ?float
    • minimum(array $nombres): ?float
    • mediane(array $nombres): ?float

  4. Fonctions statistiques

    • ecartType(array $nombres): ?float
    • variance(array $nombres): ?float

Critères :

  • ✅ Toutes les fonctions créées
  • ✅ Typage strict activé (declare(strict_types=1))
  • ✅ Gestion des erreurs (division par zéro, tableaux vides)
  • ✅ Documentation PHPDoc pour chaque fonction
  • ✅ Tests avec différentes valeurs
  • ✅ Code organisé et réutilisable

Objectif : Maîtriser les fonctions PHP et créer une bibliothèque réutilisable et bien typée.

Validation : Vous pouvez passer au module suivant quand vous maîtrisez les fonctions, le typage, et pouvez créer des fonctions réutilisables.