Le trait est une constante magique en PHP qui renvoie toujours le nom du trait dans lequel il est défini, quelle que soit la classe qui l'utilise. 1. Il est résolu au temps de compilation dans la portée du trait et ne change pas en fonction de la classe d'appel. 2. Contrairement à la classe__, qui reflète le contexte de classe actuel, __trait reste fixé au nom du trait. 3. Il est utile pour le débogage, l'exploitation forestière et les rapports d'erreurs en fournissant une identification cohérente des traits. 4. Il ne peut pas être utilisé à l'extérieur d'un trait, entra?nant une erreur mortelle si elle est tentée. 5. Méthode L'aliasage avec ?As? n'affecte pas la valeur du trait __ car le contexte interne du trait reste inchangé. Par conséquent, __trait s'auto-identifie de manière fiable le trait, garantissant un comportement prévisible dans différentes classes.

__TRAIT__ n'est pas une constante PHP intégrée - vous pensez probablement à __TRAIT__ , qui est une constante magique en php, similaire à __CLASS__ , __METHOD__ ou __FUNCTION__ . Il est utilisé spécifiquement dans le contexte des traits , et en comprenant comment il se comporte dans les classes (et dans le trait lui-même) révèle un comportement contextuel subtil mais puissant.

Décomposons la ?magie contextuelle? de __TRAIT__ et comment elle agit lorsqu'un trait est utilisé à l'intérieur d'une classe.

Ce que __TRAIT__ est réellement

__TRAIT__ est une constante magique qui renvoie le nom du trait dans lequel il est utilisé , comme cha?ne. Ce n'est significatif que dans le corps d'un trait. Tout comme __CLASS__ vous donne le nom de classe actuel, __TRAIT__ vous donne le nom entièrement qualifié du trait actuel - mais uniquement à partir du trait.

 trait mytrait {
    fonction publique gettraitName () {
        retour __trait__;
    }
}

classe myClass {
    Utilisez MyTrait;
}

$ obj = new myClass ();
echo $ obj-> gettraitName (); // Sorties: Mytrait

Jusqu'à présent, si simple. Mais c'est là que commence la magie - et la confusion -.

Comment __TRAIT__ se comporte à l'intérieur d'une classe (lorsque le trait est utilisé)

Même si les méthodes du trait sont injectées dans une classe, __TRAIT__ ne change pas en fonction de la classe en utilisant le trait. Il est résolu à l'heure de compilation , pas à l'exécution, et fait toujours référence au nom du trait - quelle que soit la classe l'utilise.

Exemple: plusieurs classes utilisant le même trait

 Logueur de trait {
    Journal des fonctions publiques ($ message) {
        écho '['. __TRAIT__ . ']'. $ message. Php_eol;
    }
}

classe utilisateur {
    Utiliser Logger;
}

Classe Product {
    Utiliser Logger;
}

$ user = new User ();
$ product = nouveau produit ();

$ user-> log ("utilisateur créé"); // [Logger] Utilisateur créé
$ product-> log ("produit ajouté"); // produit [logger] ajouté

Même si Logger est utilisé dans différentes classes, __TRAIT__ évalue toujours en 'Logger' dans les deux cas. Il ne devient pas 'User' ou 'Product' .

Ceci est différent de __CLASS__ , qui changerait en fonction du contexte d'appel:

 trait testContext {
    fonction publique showClass () {
        Echo "Classe:". __CLASSER__ . "\ n";
    }

    fonction publique showtrait () {
        écho "Trait:". __TRAIT__ . "\ n";
    }
}

Exemple de classe {
    Utiliser TestContext;
}

$ e = nouvel exemple ();
$ e-> showclass (); // Classe: Exemple
$ e-> showtrait (); // trait: testContext

Ainsi, __CLASS__ reflète la classe où la méthode est appelée , mais __TRAIT__ reflète le trait où il est défini - peu importe où il est utilisé.

Pourquoi cela compte: débogage et journalisation

Le comportement cohérent de __TRAIT__ le rend super utile dans:

• Journalisation : vous pouvez identifier d'où vient une ligne de journal, même si elle est partagée entre de nombreuses classes.
• Rapports d'erreur : lancez des exceptions avec le contexte sur lequel le trait a généré l'erreur.
• Comportement dynamique : exécutez conditionnellement le code basé sur le nom du trait (rare, mais possible).

Par exemple:

 Trait SecureAccess {
    Fonction publique CheckAccess () {
        if (! $ this-> currentUserHasaccess ()) {
            Jetez une nouvelle exception ("Accès refusé dans le trait:". __trait__);
        }
    }
}

Cela donne des messages d'erreur plus clairs que le codage en dur du nom du trait.

Principaux à retenir

• ? __TRAIT__ est résolu à l'intérieur du trait , au moment de la compilation .
• ? Il renvoie toujours le nom du trait , jamais la classe l'utilisant.
• ? Il ne peut pas être utilisé en dehors d'un trait - il n'est pas défini (entra?ne une erreur fatale).
• ? Il ne change pas en fonction du contexte de la classe - contrairement à __CLASS__ .

Ainsi, alors que __CLASS__ est contextuel à l'appelant, __TRAIT__ est auto-référentiel et fixe .

Une bizarrerie: aliasing et as

Même si vous renommez une méthode via use MyTrait::method as myMethod; , __TRAIT__ fonctionne toujours de la même manière - parce que le corps de la méthode n'a pas changé.

 trait apihelper {
    fonction publique getClient () {
        Echo "de trait:". __TRAIT__;
    }
}

classe LegacySystem {
    Utilisez ApiHelper {GetClient comme GetoldClient; }
}

$ obj = new LegacySystem ();
$ obj-> getoldClient (); // Très imprime: de Trait: Apihelper

Le renommer la méthode n'affecte pas le contexte interne du code de trait.

En bref, __TRAIT__ est un outil petit mais puissant qui maintient son identité, peu importe où il est utilisé. Son comportement est cohérent, prévisible et profondément lié à la définition du trait - pas les classes qui l'adoptent.

Fondamentalement, c'est comme un trait disant: "Peu importe où tu m'utilise, je saurai toujours qui je suis."

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!