Les fermetures et les fonctions anonymes en PHP sont utiles pour écrire un code plus propre et plus expressif. 1. Ils servent de rappels dans des fonctions de tableau comme array_map et array_filter, permettant une logique en ligne sans définir des fonctions distinctes. 2. Ils permettent l'exécution et l'encapsulation retardées, en maintenant l'état sans variables globales, comme on le voit avec l'exemple de compteur. 3. Ils permettent de passer un comportement dans d'autres fonctions, offrant une flexibilité lors de la personnalisation de la logique dans les bibliothèques ou les frameworks. 4. Ils simplifient les structures de contr?le en abstraitez des conditions répétitives ou complexes, ce qui facilite l'extension des fonctionnalités. Ces fonctionnalités aident à réduire l'encombrement, à éviter les effets secondaires et à garder ensemble les données et la logique connexes.

Les fermetures de PHP et les fonctions anonymes peuvent sembler sophistiquées, mais elles sont en fait assez utiles dans les scénarios du monde réel. Si vous avez déjà écrit ou lu du code PHP qui passe une fonction comme un argument ou conserve un état dans une fonction, vous les avez probablement déjà vus en action.

Décomposons quand et pourquoi vous souhaitez utiliser des fermetures ou des fonctions anonymes dans PHP.

Quelle est la différence entre les fermetures et les fonctions anonymes?

Avant de plonger dans les cas d'utilisation, il aide à clarifier:

• Les fonctions anonymes sont des fonctions sans nom.
• Les fermetures sont un type de fonction anonyme qui peut accéder aux variables à partir de la portée des parents (même après la fin de cette portée).

Dans PHP, la plupart du temps, où les gens disent une "fonction anonyme", ils l'utilisent de manière interchangeable avec la fermeture - d'autant plus que la classe Closure de PHP est ce qui rend l'héritage variable possible.

1. Rappels dans les fonctions du tableau

L'une des utilisations les plus courantes des fonctions anonymes dans PHP est les rappels pour les fonctions de tableau intégrées comme array_map , array_filter ou usort .

Par exemple:

 $ nombres = [1, 2, 3, 4];
$ squared = array_map (fonction ($ n) {
    retourner $ n * $ n;
}, $ nombres);

Cela vous permet de garder la logique de transformation en ligne sans avoir besoin de définir une fonction nommée distincte. Il est propre et évite d'encombrer votre espace de noms.

Quand utiliser ceci:

• Vous n'avez besoin que la fonction une seule fois.
• La logique est assez simple pour ne pas justifier une définition complète de la fonction.
• Vous travaillez dans une boucle ou une autre fonction où la définition d'un aide est inutile.

2. Exécution et encapsulation retardées

Les fermetures vous permettent d' encapsuler le comportement avec les données , ce qui signifie que vous pouvez créer des fonctions qui se souviennent de leur environnement même après avoir disparu.

Voici un exemple de base:

 fonction getcounter () {
    $ count = 0;
    return function () use (& $ count) {
        retour $ Count;
    };
}

$ compter = getCounter ();
echo $ compter (); // 1
echo $ compter (); // 2

La variable $count vit à l'intérieur de la fermeture même après que getCounter() termine l'exécution.

Pourquoi cela compte:

• Vous pouvez maintenir l'état sans compter sur des variables mondiales.
• Utile pour des choses comme les gestionnaires d'événements, le chargement paresseux ou les itérateurs personnalisés.
• Aide à réduire les effets secondaires en gardant ensemble la logique et les données connexes.

3. Passer un comportement dans d'autres fonctions

Parfois, vous voulez passer non seulement les données, mais le comportement dans une fonction. Les fermetures rendent cela facile et lisible.

Par exemple, imaginez une méthode qui traite une liste d'utilisateurs et permet la personnalisation:

 Fonction ProcessUsers (Array $ utilisateurs, Handler Callable $) {
    foreach ($ utilisateurs comme $ utilisateur) {
        $ handler ($ utilisateur);
    }
}

ProcessUsers ($ utilisateurs, fonction ($ utilisateur) {
    Echo "Traitement User: {$ user ['name']} \ n";
});

Ce type de modèle donne une flexibilité aux développeurs en utilisant votre code sans les forcer à étendre les classes ou à implémenter des interfaces.

Situations courantes:

• Personnalisation de la sortie ou du filtrage dans les bibliothèques.
• écriture des tests en double ou des simulations dans les tests unitaires.
• Implémentation de middleware ou de pipelines dans des cadres.

4. Simplifier les structures de contr?le

Vous pouvez également utiliser des fermetures pour abstraction de la logique répétitive ou simplifier les conditions complexes.

Dites que vous avez plusieurs fa?ons de formater le contenu en fonction d'une configuration:

 $ formatrs = [
    'uppercase' => function ($ text) {return strtoupper ($ text); },
    'reverse' => function ($ text) {return strrev ($ text); },
]]

$ format = 'reverse';
Echo $ formatrs [$ format] ('Hello'); // Olleh

Cela facilite l'ajout de nouveaux formats et maintient la logique de formatage hors de votre flux de code principal.

En fin de compte, les fermetures et les fonctions anonymes visent à écrire un code plus propre et plus expressif. Ils vous aident à éviter les globaux inutiles, à garder la logique près de l'endroit où il est utilisé et à donner à votre code un peu plus de flexibilité.

Ils ne sont pas toujours nécessaires, mais quand ils s'adaptent, ils nettoient vraiment les choses.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!