Programmation fonctionnelle en PHP : bases et exemples

Programmation fonctionnelle en PHP : de la théorie à la pratique

PHP est traditionnellement associé aux approches impératives et orientées objet, mais le langage moderne offre des outils puissants pour la programmation fonctionnelle (PF). Dans cet article, nous allons voir comment appliquer les principes de la PF en PHP : des fonctions anonymes au curryfication et à l'immutabilité. Vous apprendrez à rendre votre code plus prévisible, testable et concis.

1. Les bases : fonctions anonymes et fermetures

Les fonctions anonymes (lambda) sont la pierre angulaire de la PF en PHP. Elles permettent de passer un comportement comme une donnée.

<?php// Fonction anonyme simple$greet = function($name) {    return "Bonjour, $name!";};echo $greet('Monde'); // Bonjour, Monde!

// Utilisation avec array_map$numbers = [1, 2, 3, 4, 5];$squared = array_map(function($n) {    return $n * $n;}, $numbers);print_r($squared); // [1, 4, 9, 16, 25]?>

Les fermetures (closures) sont des fonctions anonymes qui capturent des variables de la portée externe à l'aide du mot-clé use :

<?php$factor = 3;$multiply = function($n) use ($factor) {    return $n * $factor;};echo $multiply(5); // 15

// Fermeture avec variable modifiable (par référence)$counter = 0;$increment = function() use (&$counter) {    $counter++;};$increment();echo $counter; // 1?>

Les fermetures sont indispensables pour créer des fonctions de rappel (callbacks) et des fabriques.

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

PHP intègre des fonctions d'ordre supérieur classiques qui acceptent d'autres fonctions comme arguments :

• array_map — transforme chaque élément d'un tableau ;
• array_filter — filtre les éléments selon une condition ;
• array_reduce — réduit un tableau à une seule valeur.

<?php$data = [1, 2, 3, 4, 5, 6];

// Filtrage des nombres pairs$even = array_filter($data, function($n) {    return $n % 2 === 0;}); // [2, 4, 6]

// Doublement de chaque élément$doubled = array_map(function($n) {    return $n * 2;}, $even); // [4, 8, 12]

// Somme de toutes les valeurs$sum = array_reduce($doubled, function($carry, $n) {    return $carry + $n;}, 0); // 24?>

Notez que array_filter conserve les clés. Si vous avez besoin d'une réindexation, utilisez array_values().

3. Immuabilité et manipulation des données

La programmation fonctionnelle encourage l'immutabilité — le caractère immuable des données. Au lieu de modifier des objets existants, on en crée de nouveaux.

<?php// Approche impérative (mutation)$user = ['name' => 'Ivan', 'age' => 25];$user['age'] = 26; // modifie le tableau d'origine

// Approche fonctionnelle (immuable)$user = ['name' => 'Ivan', 'age' => 25];$updatedUser = array_merge($user, ['age' => 26]); // nouveau tableau?>

Pour travailler avec les tableaux, utilisez array_merge, array_slice et l'opérateur spread (PHP 7.4+) :

<?php$original = [1, 2, 3];$new = [...$original, 4]; // [1, 2, 3, 4] — l'original n'a pas changé?>

L'immutabilité simplifie le débogage et rend le code thread-safe.

4. Curryfication et application partielle

La curryfication est la transformation d'une fonction à plusieurs arguments en une séquence de fonctions à un seul argument. L'application partielle consiste à fixer une partie des arguments.

PHP n'a pas de curryfication intégrée, mais elle est facile à implémenter :

<?php// Fonction d'addition curryfiéefunction curryAdd($a) {    return function($b) use ($a) {        return function($c) use ($a, $b) {            return $a + $b + $c;        };    };}

$add5 = curryAdd(5);```