0Pricing
PHP Academy · Leçon

Fonctions anonymes et fermetures

Écrivez des fonctions intégrées et capturez des variables avec use.

Fonctions anonymes et fermetures est une leçon PHP Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage PHP Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours PHP Academy comprend 4 leçons au total.

Que sont les fonctions anonymes ?

Une fonction anonyme (lambda) est une fonction sans nom. En PHP, il s'agit d'une instance de la classe intégrée Closure qui peut être stockée dans une variable, transmise comme argument ou renvoyée par une autre fonction.

Fonction anonyme élémentaire

Affectez une fonction à une variable, puis appelez-la :

<?php
$double = function(int $n): int {
    return $n * 2;
};

echo $double(5);   // 10
echo $double(21);  // 42

Transmettre des fonctions anonymes

Transmettez une fermeture comme argument à des fonctions telles que array_map, usort ou vos propres fonctions de rappel :

<?php
$nums = [3, 1, 4, 1, 5, 9];

$squared = array_map(function(int $n): int {
    return $n ** 2;
}, $nums);

print_r($squared); // [9, 1, 16, 1, 25, 81]

Renvoyer des fonctions

Une fonction peut créer et renvoyer une fermeture — il s'agit du motif de fabrique :

<?php
function makeMultiplier(int $factor): Closure {
    return function(int $n) use ($factor): int {
        return $n * $factor;
    };
}

$triple  = makeMultiplier(3);
$tenX    = makeMultiplier(10);

echo $triple(5);   // 15
echo $tenX(5);     // 50

Fermetures et use

Les fermetures peuvent capturer des variables de la portée externe avec use. La capture se fait par valeur (copie), sauf si vous ajoutez & :

<?php
$taxRate = 0.18;

$addTax = function(float $price) use ($taxRate): float {
    return $price * (1 + $taxRate);
};

$taxRate = 0.20;  // change outer variable
echo $addTax(100); // 118 — captured value at creation time

Capture par référence avec use(&)

Pour permettre à la fermeture de voir les valeurs externes mises à jour, effectuez une capture par référence :

<?php
$count = 0;

$increment = function() use (&$count): void {
    $count++;
};

$increment();
$increment();
echo $count;  // 2

Fonctions fléchées (PHP 7.4)

Les fonctions fléchées sont des fermetures compactes à expression unique qui capturent automatiquement la portée externe par valeur :

<?php
$rate = 1.18;
$prices = [10, 20, 30];

// Arrow function — no 'use' needed
$withTax = array_map(fn($p) => $p * $rate, $prices);

print_r($withTax); // [11.8, 23.6, 35.4]

Les fonctions fléchées ne peuvent pas modifier la portée externe

Les fonctions fléchées capturent uniquement par valeur — elles ne peuvent pas modifier les variables externes :

<?php
$total = 0;
$nums  = [1, 2, 3];

// This does NOT modify $total!
array_walk($nums, fn($n) => $total += $n);

echo $total;  // 0

// Use a reference closure for mutation:
array_walk($nums, function($n) use (&$total) { $total += $n; });
echo $total;  // 6

Fermetures comme fonctions de rappel

De nombreuses fonctions PHP acceptent une valeur appelable — vous pouvez transmettre une fermeture, un tableau [$obj, 'method'] ou le nom d'une fonction sous forme de chaîne :

<?php
$words = ['banana', 'apple', 'cherry'];

usort($words, fn($a, $b) => strcmp($a, $b));

print_r($words); // ['apple', 'banana', 'cherry']

Fermeture appelée immédiatement

Vous pouvez définir et appeler une fermeture sur la même ligne — c'est utile pour créer une portée isolée :

<?php
$result = (function(): int {
    $x = 10;
    $y = 20;
    return $x + $y;
})();

echo $result; // 30
// $x and $y are not in outer scope

Closure::bind et bindTo

Vous pouvez rattacher une fermeture au contexte d'un autre objet avec Closure::bind() :

<?php
class Counter {
    private int $value = 0;
}

$increment = Closure::bind(function(int $by): void {
    $this->value += $by;
}, new Counter(), Counter::class);

// Now $increment has access to private $value

Vérification rapide

Quelle est la principale différence entre une fermeture ordinaire avec use et une fonction fléchée en PHP ?

Récapitulatif : fonctions anonymes et fermetures

Résumé :

  • Les fonctions anonymes sont stockées dans des variables et transmises
  • Les fermetures capturent les variables externes avec use($var) (par valeur) ou use(&$var) (par référence)
  • Les fonctions fléchées (PHP 7.4) capturent automatiquement la portée externe par valeur
  • Utiles pour les fonctions de rappel : array_map, usort, array_filter…
  • Elles peuvent être renvoyées par des fonctions fabriques

Questions Fréquemment Posées

La leçon « Fonctions anonymes et fermetures » est-elle gratuite ?

Oui — le texte complet de « Fonctions anonymes et fermetures » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours PHP Academy, passe à CoddyKit PRO. Le cours PHP Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Fonctions anonymes et fermetures » ?

Écrivez des fonctions intégrées et capturez des variables avec use. Tu pratiques PHP Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer PHP Academy ?

Aucune expérience préalable n'est requise. PHP Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Fonctions anonymes et fermetures » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon PHP Academy ?

Oui. Chaque leçon PHP Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Définir et appeler des fonctions
  2. Paramètres par défaut et variadiques
  3. Portée des variables : locale et globale
  4. Fonctions anonymes et fermetures
← Retour à PHP Academy