Les fonctions flèches de PHP éliminent le besoin d'utiliser les mots clés en capturant automatiquement les variables de portée des parents; 2. Ils ne peuvent contenir qu'une seule expression et capturer des variables par valeur; 3. Il convient aux scénarios tels que la conversion du tableau, le tri dynamique et les rappels simples; 4. Il ne convient pas aux fonctions complexes qui nécessitent un passage de référence ou une logique multi-lignes; 5. L'utilisation des fonctions Arrow peut réduire le code du chaudron et améliorer la lisibilité du code, ce qui est un meilleur choix lorsqu'il s'agit de fermetures simples.

PHP a longtemps pris en charge les fonctions anonymes (fermetures), permettant aux développeurs de définir des fonctions à la volée et de les transmettre en tant que rappels. Avec PHP 8.1, une nouvelle syntaxe a été introduite: Arrow Functions 2.0 - une fa?on plus concise d'écrire des fermetures qui héritent automatiquement des variables de la portée parentale. Ce n'est pas seulement du sucre syntaxique; Il représente un changement dans la fa?on dont nous gérons la portée des variables dans les fermetures, ce qui rend le code plus propre et moins sujet aux erreurs.

Décomposons ce qui fait de la flèche de PHP un nouveau paradigme pour l'héritage de la portée variable.

Quelles sont les fonctions de flèche dans PHP?

Les fonctions de flèche, introduites dans PHP 7.4 et améliorées en PHP 8.1, fournissent une syntaxe raccourci pour écrire de courtes fonctions anonymes. Ils utilisent le mot-clé fn et la syntaxe "flèche" ( => ):

 $ multiplicateur = 2;
$ nombres = array_map (fn ($ n) => $ n * $ multiplicateur, [1, 2, 3, 4]);

Cela équivaut à la syntaxe de fermeture plus longue:

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

La principale différence? Héritage variable automatique.

Héritage automatique de la portée: plus d' use

Avant les fonctions de flèche, si vous vouliez accéder à une variable à partir de la portée des parents à l'intérieur d'une fermeture, vous deviez l'importer explicitement à l'aide du mot-clé use :

 fonction getDiscountEdPrices ($ items, $ remise) {
    return array_map (fonction ($ price) use ($ recount) {
        Retour $ Price * (1 - $ Discount);
    }, $ items);
}

Oublier use conduit à des erreurs variables non définies. Il est facile de manquer, surtout dans la logique imbriquée.

Avec les fonctions de flèche, toutes les variables référencées à l'intérieur de la fonction sont automatiquement capturées à partir de la portée extérieure par valeur :

 fonction getDiscountEdPrices ($ items, $ remise) {
    return array_map (fn ($ prix) => $ prix * (1 - $ remise), $ items);
}

Aucune use , pas d'erreurs. La variable $discount est capturée implicitement.

Comment fonctionne l'héritage de la portée dans les fonctions Arrow

Les fonctions de flèche suivent des règles spécifiques pour la portée variable:

• Seules les variables utilisées dans la fonction de flèche sont capturées.
• La capture est par valeur, pas par référence.
• Seules les variables de la portée des parents immédiates sont disponibles.
• $ Ceci est conservé s'il est défini dans la portée des parents.

Par exemple:

 Classe Product {
    Taxe de $ privé = 0,1;

    Fonction publique CalculePrices ($ Prix) {
        retour array_map (fn ($ prix) => $ prix * (1 $ this-> tax), $ prix);
    }
}

Ici, $this est disponible à l'intérieur de la fonction de flèche car il est dans la portée où la fonction de flèche est définie. Vous n'avez pas besoin d' use ($this) ou de vous soucier de la liaison.

Mais si vous essayez d'accéder à une variable non pas dans la portée:

 fn ($ x) => $ x * $ inconnuvar // erreur fatale si $ inconnu n'existe pas

Il se comporte comme tout accès variable normal - se fait non défini.

Limitations et quand ne pas utiliser les fonctions flèches

Bien que pratique, les fonctions de flèche ne remplacent pas toutes les fermetures. Ils ont des contraintes:

• Expression unique uniquement : le corps doit être une expression unique (pas de plusieurs instructions).
• Aucune instruction de retour : l'expression est automatiquement renvoyée.
• Impossible de capturer les variables par référence : vous ne pouvez pas modifier directement les variables extérieures.
• Moins lisible pour une logique complexe : gardez-les court et simples.

Donc cela ne fonctionnera pas:

 fn ($ x) => {
    Echo "Traitement $ x \ n";
    retourner $ x * 2;
}

Vous avez besoin d'une fermeture complète pour la logique multi-lignes.

De plus, si vous avez besoin de passer des variables par référence:

 $ facteur = 2;
$ double = fonction (& $ valeur) use (& $ factor) {
    $ valeur * = $ facteur;
};

Les fonctions Arrow ne peuvent pas le faire - la capacité est toujours par valeur.

Meilleures pratiques et cas d'utilisation du monde réel

Les fonctions de flèche brillent dans les modèles de programmation fonctionnelle:

1. Transformations de tableau

 $ users = array_filter ($ utilisateurs, fn ($ user) => $ user-> isActive ());
$ names = array_map (fn ($ user) => $ user-> name, $ utilisateurs);

2. Tri avec des critères dynamiques

 $ sortby = 'age';
USORT ($ People, fn ($ a, $ b) => $ a -> $ sortby <=> $ b -> $ sortby);

3. Rappels d'événements ou logique différée

 $ logger = new logger ();
$ onSave = fn ($ disques) => $ logger-> info ("enregistré:". $ enregistre-> id);

Ils réduisent le chauffeur et rendent l'intention plus claire, en particulier lorsque la logique est triviale.

Résumé

Les fonctions de flèche de PHP représentent une évolution subtile mais significative dans la fa?on dont les fermetures interagissent avec la portée variable. En capturant automatiquement les variables utilisées de la portée des parents, ils éliminent le besoin de certificats use verbeux, réduisent les bogues et encouragent le code plus propre et plus expressif.

Ils ne sont pas pour toutes les situations, mais lorsqu'ils sont utilisés de manière appropriée, en particulier pour les rappels courts et apatrides - ils rendent le code plus lisible et maintenu.

Fondamentalement: si votre fermeture est une seule ligne qui utilise des variables de l'extérieur, atteignez fn() => . Ce n'est pas seulement plus court - il est plus intelligent à propos de la portée.

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!