Les Fonctions en PHP

function nomDeLaFonction($parametre1, $parametre2) {
    // Instructions à exécuter
    $resultat = /* traitement des paramètres */;
    return $resultat;
}

Les éléments de base d'une fonction :

• Mot-clé function pour déclarer une fonction
• Nom de la fonction (doit commencer par une lettre ou un underscore)
• Paramètres entre parenthèses (séparés par des virgules)
• Corps de la fonction entre accolades
• Instruction de retour (facultative) avec return

function addition($a, $b) {
    $resultat = $a + $b;
    return $resultat;
}

function calculerSurfaceRectangle($longueur, $largeur) {
    // Vérification des valeurs
    if ($longueur <= 0 || $largeur <= 0) {
        return "Dimensions invalides";
    }
    
    // Calcul de la surface
    $surface = $longueur * $largeur;
    
    // Retourne le résultat
    return $surface;
}

function afficherMessage($prenom) {
    echo "
Bonjour $prenom et bienvenue sur mon site!
";
}

function saluer($nom, $formule = "Bonjour") {
    return "$formule $nom !";
}

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

function calculerTotal($taxe, ...$prix) {
    $somme = array_sum($prix);
    return $somme * (1 + $taxe/100);
}

function incrementer(&$valeur, $increment = 1) {
    $valeur += $increment;
}

La variable $nombre a été modifiée directement par la fonction, sans utiliser de valeur de retour.

function calculerAire(float $longueur, float $largeur): float {
    return $longueur * $largeur;
}

function factorielle($n) {
    // Cas de base
    if ($n <= 1) return 1;
    
    // Appel récursif
    return $n * factorielle($n - 1);
}

factorielle(5)
└── 5 * factorielle(4) = 5 * 24 = 120
    └── 4 * factorielle(3) = 4 * 6 = 24
        └── 3 * factorielle(2) = 3 * 2 = 6
            └── 2 * factorielle(1) = 2 * 1 = 2
                └── factorielle(1) = 1 (cas de base)
                        

$calculerCarre = function($nombre) {
    return $nombre * $nombre;
};

// Utilisation comme fonction de tri
$fruits = ['pomme', 'banane', 'fraise'];
usort($fruits, function($a, $b) {
    return strlen($a) - strlen($b); // Trie par longueur
});

Array
(
    [0] => kiwi
    [1] => pomme
    [2] => banane
    [3] => fraise
)

// Syntaxe des fonctions fléchées
$multiplier = fn($a, $b) => $a * $b;

// Les variables extérieures sont capturées automatiquement
$prix = 100;
$calculerTVA = fn($taux = 20) => $prix * $taux / 100;

// Dans un tableau avec array_map
$nombres = [1, 2, 3, 4, 5];
$doubles = array_map(fn($n) => $n * 2, $nombres);

function executerOperation(callable $operation, $a, $b) {
    return $operation($a, $b);
}

// Différentes façons d'appeler cette fonction
function additionner($x, $y) {
    return $x + $y;
}

// 1. Avec le nom d'une fonction
$resultat1 = executerOperation('additionner', 5, 3);

// 2. Avec une fonction anonyme
$resultat2 = executerOperation(function($x, $y) {
    return $x * $y;
}, 5, 3);

// 3. Avec une méthode d'objet
$calculateur = new Calculateur();
$resultat3 = executerOperation([$calculateur, 'soustraire'], 5, 3);

Le type callable permet d'accepter différentes formes de fonctions comme paramètre, ce qui rend votre code extrêmement flexible. C'est la base de nombreux design patterns en PHP.

function maFonction() {
    $variableLocale = "Je suis locale";
    echo $variableLocale;  // Fonctionne
}

maFonction();
echo $variableLocale;  // Erreur ! $variableLocale n'existe pas ici

$variableGlobale = "Je suis globale";

function accederGlobale() {
    global $variableGlobale; // Déclaration d'accès à la variable globale
    echo $variableGlobale;
}

function modifierGlobale() {
    global $variableGlobale;
    $variableGlobale = "Valeur modifiée";
}

// Alternative avec le tableau $GLOBALS
function autreMethode() {
    $GLOBALS['variableGlobale'] = "Nouvelle valeur";
}

function compteur() {
    static $compte = 0; // Initialisée une seule fois
    $compte++; // Incrémentée à chaque appel
    return $compte;
}
wamp
// Exemple de cas pratique : mise en cache
function getDatabase() {
    static $connexion = null;
    
    if ($connexion === null) {
        // Connexion coûteuse, n'est faite qu'une seule fois
        $connexion = "Connexion établie"; // Dans la réalité: new PDO(...)
        echo "
Nouvelle connexion
";
    } else {
        echo "
Réutilisation de la connexion existante
";
    }
    
    return $connexion;
}

Créez une fonction qui calcule le produit de deux nombres

function multiplier(float $a, float $b): float {
    return $a * $b;
}

// Test de la fonction
echo "4 × 5 = " . multiplier(4, 5); // Affiche 20

function multiplier($a, $b) {
    // Vérifier que les paramètres sont bien numériques
    if (!is_numeric($a) || !is_numeric($b)) {
        return "Erreur: les paramètres doivent être des nombres";
    }
    
    return $a * $b;
}

Créez une fonction qui calcule la somme des éléments d'un tableau

function sommeTableau(array $tableau): float {
    $somme = 0;
    foreach ($tableau as $valeur) {
        $somme += $valeur;
    }
    return $somme;
}

Créez une fonction qui compte les voyelles dans une chaîne

function compterVoyelles(string $chaine): int {
    $voyelles = ['a', 'e', 'i', 'o', 'u', 'y', 
                'A', 'E', 'I', 'O', 'U', 'Y'];
    $compteur = 0;
    
    for ($i = 0; $i < strlen($chaine); $i++) {
        if (in_array($chaine[$i], $voyelles)) {
            $compteur++;
        }
    }
    
    return $compteur;
}

Créez une fonction qui filtre les éléments d'un tableau selon un critère

function filtrerTableau(array $tableau, callable $critere): array {
    $resultat = [];
    
    foreach ($tableau as $cle => $valeur) {
        if ($critere($valeur)) {
            $resultat[$cle] = $valeur;
        }
    }
    
    return $resultat;
}

Créez une fonction récursive qui calcule les nombres de la suite de Fibonacci

function fibonacci(int $n): int {
    // Cas de base
    if ($n <= 1) {
        return $n;
    }
    
    // Appel récursif
    return fibonacci($n - 1) + fibonacci($n - 2);
}