Master les fermetures de PHP et le mot-clé «utilisation» pour la portée lexicale

Les fermetures PHP avec le mot clé Utiliser permettent la portée lexicale en capturant les variables de la portée des parents. 1. Les fermetures sont des fonctions anonymes qui peuvent accéder aux variables externes via l'utilisation. 2. Par défaut, les variables utilisées sont passées par valeur; Pour les modifier à l'extérieur, utilisez et $ variable pour référence. 3. Les cas d'utilisation courants incluent les fonctions de rappel avec le contexte, l'exécution différée comme les gestionnaires d'événements et l'injection de dépendance sans classes. 4. Évitez les pièges communs tels que la capture variable inutile et la liaison variable de boucle incorrecte - bien que PHP lie correctement les variables de boucle utilisées par valeur par itération, contrairement à JavaScript. 5. Les meilleures pratiques incluent l'utilisation de la sémantique de valeur à moins que la mutation soit nécessaire, le choix des noms de variables clairs et le fait d'être prudent avec les références. Lorsqu'ils sont utilisés correctement, les fermetures améliorent la modularité et la lisibilité du code en encapsulant la logique avec un accès contrôlé à l'état externe.

Les fermetures de PHP - en particulier lorsqu'elles sont combinées avec le mot clé use - sont des outils puissants pour créer du code flexible et encapsulé. Bien qu'ils puissent sembler délicats au début, comprendre comment ils fonctionnent avec les modèles de code plus propres et plus maintenables.

Décomposons comment les fermetures fonctionnent en PHP, pourquoi l' use des mots clés compte et comment les utiliser efficacement.

Qu'est-ce qu'une fermeture en PHP?

Une fermeture est une fonction anonyme qui peut capturer des variables à partir de la portée environnante (entourée). Contrairement aux fonctions régulières, les fermetures peuvent "se souvenir" des variables même après la fin de l'exécution de la portée des parents.

 $ salutation = "bonjour";
$ sayhello = fonction ($ name) use ($ salutation) {
    echo "$ salutation, $ name! \ n";
};

$ Sayhello ("Alice"); // Sortie: Bonjour, Alice!

Ici, la fermeture utilise la variable $greeting à partir de la portée extérieure via le mot clé use .

Comment use permet la portée lexicale

Le mot clé use permet à une fermeture d' importer des variables de la portée des parents dans sa propre portée. C'est ce qu'on appelle la portée lexicale - la fermeture "se ferme" sur les variables qu'il fait référence.

Règles d' use clés:

• Les variables sont copiées par valeur par défaut.
• Pour modifier une variable à l'intérieur de la fermeture et refléter les modifications à l'extérieur, vous devez la transmettre par référence en utilisant & .
• Vous ne pouvez pas utiliser $this dans une fermeture à moins que ce soit dans un contexte de classe (et même alors, il est automatiquement disponible).

Exemple: valeur vs référence

 $ count = 0;

// par valeur (par défaut)
$ incrémentablevalue = function () use ($ count) {
    Nombre $;
};

$ incrémentyValue ();
Echo $ Count; // toujours 0

// par référence
$ incmenmentByReference = function () use (& $ count) {
    Nombre $;
};

$ incrémentyreference ();
Echo $ Count; // maintenant 1

⚠️ Si vous avez besoin de la fermeture pour affecter l'état externe, utilisez toujours &$variable .

Cas d'utilisation pratiques pour les fermetures et use

Les fermetures brillent dans les scénarios où vous souhaitez encapsuler la logique avec une configuration ou un retard d'exécution .

1. Fonctions de rappel avec contexte

Lorsque vous passez des rappels, vous devez souvent inclure un contexte qui ne fait pas partie des arguments de fonction.

 fonction filterbyThreshold ($ items, $ min) {
    return array_filter ($ items, fonction ($ item) use ($ min) {
        Retour $ item> = $ min;
    });
}

$ nombres = [5, 10, 15, 20];
$ filtory = filterByThreshold ($ Numbers, 12);
// Résultat: [15, 20]

Ici, $min est transmis dans la fermeture par use , ce qui rend la logique filtrante propre et réutilisable.

2. Manipatives d'événements ou logique différée

Les fermetures peuvent capturer l'état d'environnement pour une exécution ultérieure.

 $ logger = fonction ($ message) {
    écho "[". Date ('ym-d'). "] $ message \ n";
};

$ onUserLogin = fonction ($ username) use ($ logger) {
    $ logger ("utilisateur '$ username' connecté.");
};

$ onUserlogin ("bob");
// Sortie: [2025-04-05] L'utilisateur «Bob» s'est connecté.

Même si le $logger original change plus tard, la fermeture maintient sa propre copie (ou référence).

3. Injection de dépendance sans classes

Parfois, vous n'avez pas besoin d'une classe complète - juste une unité de logique autonome avec des dépendances.

 fonction CreateMultiplier ($ factor) {
    Fonction de retour ($ Number) Use ($ Factor) {
        Retour $ numéro * $ facteur;
    };
}

$ Doubler = CreateMultiplier (2);
$ tripler = CreateMultiplier (3);

Echo $ Doubler (5); // 10
Echo $ tripler (5); // 15

Ce modèle est léger et lisible - parfait pour les fonctions utilitaires.

Pièges et meilleures pratiques courantes

• ❌ use pas de variables inutiles - elle regroupe la fermeture et peut provoquer des fuites de mémoire.
• ✅ Préférez la sémantique de valeur à moins que vous ayez explicitement besoin de modifier la variable extérieure.
• ✅ Utilisez des noms de variables significatifs dans les fermetures - ils ne sont pas toujours évidents lors du débogage.
• ? Soyez prudent avec les boucles - une erreur courante consiste à capturer les variables de boucle incorrectement.

Gotcha: liaison variable de boucle

 $ functions = [];
pour ($ i = 0; $ i <3; $ i) {
    $ functions [] = fonction () use ($ i) {
        Echo $ i. "\ n";
    };
}

foreach ($ fonctionne comme $ f) {
    $ f ();
}
// Sortie: 3, 3, 3 - pas 0, 1, 2!

Pourquoi? Parce que $i est utilisé par valeur une fois la boucle terminée (où $i === 3 ). Pour le réparer:

 pour ($ i = 0; $ i <3; $ i) {
    $ functions [] = fonction () use ($ i) {
        Echo $ i. "\ n";
    };
}

Attendre - même code? En fait, dans PHP, cela fonctionne correctement car chaque itération crée une nouvelle portée à use . Cela fait donc la sortie 0 , 1 , 2 . (Contrairement à JavaScript, PHP le gère mieux.)

Mais si vous modifiiez $i par référence ou que vous le réutilisiez, des problèmes pourraient encore survenir.

Résumé

• Les fermetures sont des fonctions anonymes qui peuvent capturer des variables via use .
• use des variables d'importation par valeur sauf si préfixées avec & pour référence.
• Ils sont idéaux pour les rappels, la configuration et la logique encapsulante avec le contexte.
• Soyez conscient de la portée, de la mutabilité et du comportement de boucle.

Utilisées judicieusement, les fermetures de PHP rendent le code plus expressif et modulaire - aucune classe requise.

Fondamentalement, n'oubliez pas: use donne à votre fermeture l'accès au monde extérieur, mais seulement ce que vous autorisez explicitement.

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!