Programmation fonctionnelle en PHP : de A à Z — guide complet

Introduction à la programmation fonctionnelle en PHP

La programmation fonctionnelle (PF) est un paradigme dans lequel les calculs sont considérés comme l'évaluation de fonctions mathématiques, en évitant les changements d'état et les données mutables. Bien que PHP ait été initialement créé comme un langage impératif, à partir de la version 5.3 (2009), des outils puissants pour le style fonctionnel ont été ajoutés : fonctions anonymes, fermetures, support des fonctions d'ordre supérieur et bien plus encore.

Dans cet article, nous allons analyser tous les concepts clés de la programmation fonctionnelle en PHP — des fonctions anonymes de base aux techniques avancées comme la curryfication et la composition de fonctions. Vous apprendrez à écrire un code plus propre, plus prévisible et plus testable.

1. Fonctions anonymes et fermetures (Closures)

Fonctions anonymes

Une fonction anonyme (lambda) est une fonction sans nom. Elle peut être assignée à une variable, passée comme argument ou retournée depuis une autre fonction.

<?php// Fonction anonyme classique$square = function($n) {    return $n * $n;};

echo $square(5); // 25

// Fonction anonyme comme callback pour array_map$numbers = [1, 2, 3, 4];$squared = array_map(function($n) {    return $n * $n;}, $numbers);

print_r($squared); // [1, 4, 9, 16]?>

Fermetures (Closures)

Une fermeture est une fonction anonyme qui peut capturer des variables de la portée externe à l'aide du mot-clé use. C'est l'une des fonctionnalités les plus puissantes de la PF en PHP.

<?php$multiplier = 3;

$multiply = function($n) use ($multiplier) {    return $n * $multiplier;};

echo $multiply(10); // 30

// Variable modifiable (passée par référence)$counter = 0;$increment = function() use (&$counter) {    $counter++;};

$increment();$increment();echo $counter; // 2?>

2. Fonctions pures et immutabilité des données

Fonctions pures

Une fonction pure est une fonction qui :

• Retourne toujours le même résultat pour les mêmes arguments (déterministe)
• N'a pas d'effets secondaires (ne modifie pas les variables externes, n'affiche pas de données, n'interagit pas avec la base de données)

<?php// Fonction NON pure (dépend d'une variable globale)$taxRate = 0.2;function calculatePriceDirty($price) {    global $taxRate;    return $price * (1 + $taxRate);}

// Fonction purefunction calculatePricePure($price, $taxRate) {    return $price * (1 + $taxRate);}

echo calculatePricePure(100, 0.2); // 120 — toujours prévisible?>

Immutabilité (Immutability)

En PF, on évite de modifier les données existantes, on crée plutôt de nouvelles données. En PHP, on peut utiliser des objets immuables ou simplement retourner de nouveaux tableaux.

<?php// Mauvais : modification du tableau original$numbers = [1, 2, 3];array_push($numbers, 4); // mutation

// Bon : création d'un nouveau tableau$numbers = [1, 2, 3];$newNumbers = array_merge($numbers, [4]);

// Fonction retournant un nouveau tableaufunction addItem(array $arr, $item): array {    $result = $arr;    $result[] = $item;    return $result;}

$original = [1, 2];$updated = addItem($original, 3);print_r($original); // [1, 2] — l'original n'a pas changéprint_r($updated);  // [1, 2, 3]?>

3. Fonctions d'ordre supérieur : array_map, array_filter, array_reduce

Les fonctions d'ordre supérieur sont des fonctions qui acceptent d'autres fonctions comme arguments ou les retournent. PHP intègre trois fonctions clés pour travailler avec les tableaux en style fonctionnel.

array_map — transformation des éléments

<?php$users = [    ['name' => 'Alice', 'age' => 25],    ['name' => 'Bob', 'age' => 30],];

// Extraction des noms uniquement$names = array_map(function($user) {    return $user['name'];}, $users);

print_r(