Aperçu des attributs

    (PHP 8)

    Les attributs PHP fournissent des métadonnées structurées et lisibles par machine pour les classes, méthodes, fonctions, paramètres, propriétés et constantes. Ils peuvent être inspectés à l'exécution via l'API de réflexion, permettant un comportement dynamique sans modifier le code. Les attributs offrent un moyen déclaratif d'annoter le code avec des métadonnées.

    Les attributs permettent de découpler l'implémentation d'une fonctionnalité de son utilisation. Alors que les interfaces définissent une structure en imposant des méthodes, les attributs fournissent des métadonnées sur plusieurs éléments, y compris les méthodes, fonctions, propriétés et constantes. Contrairement aux interfaces, qui imposent l'implémentation de méthodes, les attributs annotent le code sans en modifier la structure.

    Les attributs peuvent compléter ou remplacer des méthodes d'interface optionnelles en fournissant des métadonnées plutôt qu'une structure imposée. Prenons une interface ActionHandler qui représente une opération dans une application. Certaines implémentations peuvent nécessiter une étape d'initialisation, tandis que d'autres non. Plutôt que d'obliger toutes les classes implémentant ActionHandler à définir une méthode setUp(), un attribut peut indiquer les besoins en initialisation. Cette approche augmente la flexibilité en permettant d'appliquer les attributs plusieurs fois si nécessaire.

    Exemple #1 Implémentation de méthodes optionnelles d'une interface avec des attributs

    <?php
    interface ActionHandler
    {
    public function     execute();
    }

    #[    Attribute]
    class     SetUp {}

    class     CopyFile implements ActionHandler
    {
    public     string $fileName;
    public     string $targetDirectory;

    #[    SetUp]
    public function     fileExists()
    {
    if (!    file_exists($this->fileName)) {
    throw new     RuntimeException("Le fichier n'existe pas.");
    }
    }

    #[    SetUp]
    public function     targetDirectoryExists()
    {
    if (!    file_exists($this->targetDirectory)) {
    mkdir($this->targetDirectory);
    } elseif (!    is_dir($this->targetDirectory)) {
    throw new     RuntimeException("Le répertoire cible $this->targetDirectory n'est pas un répertoire.");
    }
    }

    public function     execute()
    {
    copy($this->fileName, $this->targetDirectory . '/' . basename($this->fileName));
    }
    }

    function     executeAction(ActionHandler $actionHandler)
    {
    $reflection = new ReflectionObject($actionHandler);

    foreach (    $reflection->getMethods() as $method) {
    $attributes = $method->getAttributes(SetUp::class);

    if (    count($attributes) > 0) {
    $methodName = $method->getName();

    $actionHandler->$methodName();
    }
    }

    $actionHandler->execute();
    }

    $copyAction = new CopyFile();
    $copyAction->fileName = "/tmp/foo.jpg";
    $copyAction->targetDirectory = "/home/user";

    executeAction($copyAction);

    Found A Problem?

    Learn How To Improve This Page • Submit a Pull Request • Report a Bug
    ＋add a note

    User Contributed Notes 2 notes

    up
    42
    Harshdeep
    3 years ago
    While the example displays us what we can accomplish with attributes, it should be kept in mind that the main idea behind attributes is to attach static metadata to code (methods, properties, etc.).

    This metadata often includes concepts such as "markers" and "configuration". For example, you can write a serializer using reflection that only serializes marked properties (with optional configuration, such as field name in serialized file). This is reminiscent of serializers written for C# applications.

    That said, full reflection and attributes go hand in hand. If your use case is satisfied by inheritance or interfaces, prefer that. The most common use case for attributes is when you have no prior information about the provided object/class.

    <?php
    interface JsonSerializable
    {
    public function     toJson() : array;
    }
    ?>

    versus, using attributes,
    <?php

    #[Attribute]
    class     JsonSerialize
    {
    public function     __constructor(public ?string $fieldName = null) {}
    }

    class     VersionedObject
    {
    #[    JsonSerialize]
    public const     version = '0.0.1';
    }

    public class     UserLandClass extends VersionedObject
    {
    #[    JsonSerialize('call it Jackson')]
    public     string $myValue;
    }

    ?>
    The example above is a little extra convoluted with the existence of the VersionedObject class as I wished to display that with attribute mark ups, you do not need to care how the base class manages its attributes (no call to parent in overriden method).
    up
    37
    Florian Krmer
    2 years ago
    I've tried Harshdeeps example and it didn't run out of the box and I think it is not complete, so I wrote a complete and working naive example regarding attribute based serialization.

    <?php
    declare(strict_types=1);

    #[    Attribute(Attribute::TARGET_CLASS_CONSTANT|Attribute::TARGET_PROPERTY)]
    class     JsonSerialize
    {
    public function     __construct(public ?string $fieldName = null) {}
    }

    class     VersionedObject
    {
    #[    JsonSerialize]
    public const     version = '0.0.1';
    }

    class     UserLandClass extends VersionedObject
    {
    protected     string $notSerialized = 'nope';

    #[    JsonSerialize('foobar')]
    public     string $myValue = '';

    #[    JsonSerialize('companyName')]
    public     string $company = '';

    #[    JsonSerialize('userLandClass')]
    protected ?    UserLandClass $test;

    public function     __construct(?UserLandClass $userLandClass = null)
    {
    $this->test = $userLandClass;
    }
    }

    class     AttributeBasedJsonSerializer {

    protected const     ATTRIBUTE_NAME = 'JsonSerialize';

    public function     serialize($object)
    {
    $data = $this->extract($object);

    return     json_encode($data, JSON_THROW_ON_ERROR);
    }

    protected function     reflectProperties(array $data, ReflectionClass $reflectionClass, object $object)
    {
    $reflectionProperties = $reflectionClass->getProperties();
    foreach (    $reflectionProperties as $reflectionProperty) {
    $attributes = $reflectionProperty->getAttributes(static::ATTRIBUTE_NAME);
    foreach (    $attributes as $attribute) {
    $instance = $attribute->newInstance();
    $name = $instance->fieldName ?? $reflectionProperty->getName();
    $value = $reflectionProperty->getValue($object);
    if (    is_object($value)) {
    $value = $this->extract($value);
    }
    $data[$name] = $value;
    }
    }

    return     $data;
    }

    protected function     reflectConstants(array $data, ReflectionClass $reflectionClass)
    {
    $reflectionConstants = $reflectionClass->getReflectionConstants();
    foreach (    $reflectionConstants as $reflectionConstant) {
    $attributes = $reflectionConstant->getAttributes(static::ATTRIBUTE_NAME);
    foreach (    $attributes as $attribute) {
    $instance = $attribute->newInstance();
    $name = $instance->fieldName ?? $reflectionConstant->getName();
    $value = $reflectionConstant->getValue();
    if (    is_object($value)) {
    $value = $this->extract($value);
    }
    $data[$name] = $value;
    }
    }

    return     $data;
    }

    protected function     extract(object $object)
    {
    $data = [];
    $reflectionClass = new ReflectionClass($object);
    $data = $this->reflectProperties($data, $reflectionClass, $object);
    $data = $this->reflectConstants($data, $reflectionClass);

    return     $data;
    }
    }

    $userLandClass = new UserLandClass();
    $userLandClass->company = 'some company name';
    $userLandClass->myValue = 'my value';

    $userLandClass2 = new UserLandClass($userLandClass);
    $userLandClass2->company = 'second';
    $userLandClass2->myValue = 'my second value';

    $serializer = new AttributeBasedJsonSerializer();
    $json = $serializer->serialize($userLandClass2);

    var_dump(json_decode($json, true));
    ＋add a note
    To Top