Liste des attributs PHP 8.5 : le guide complet pour débuter

Depuis plusieurs années, le langage PHP évolue de façon rapide et régulière. Avec l’arrivée de PHP 7, puis PHP 8, et maintenant PHP 8.5, il est devenu beaucoup plus moderne, plus structuré et plus agréable à utiliser au quotidien. Parmi ces évolutions, une fonctionnalité a profondément changé la manière de travailler dans nos applications : les attributs. Si vous venez d’un monde où l’on utilisait des commentaires spéciaux ou des annotations à la manière de certains frameworks, les attributs vont vous permettre d’aller beaucoup plus loin, tout en conservant un code propre, simple et lisible.

Dans ce guide complet des attribut PHP, nous allons prendre le temps d’explorer ces attributs disponibles avec PHP 8.5. Nous allons d’abord comprendre ce qu’est un attribut, puis apprendre à les utiliser dans vos classes, vos méthodes ou vos propriétés.

Nous verrons également l’attribut #[Override], l’un des plus souvent cité depuis PHP 8.3, et nous irons plus loin avec différents exemples et bonnes pratiques. Le but est clair : que vous puissiez repartir avec une compréhension complète et concrète, même si vous débutez en PHP.

Vous allez voir que ce sujet, même s’il peut impressionner au premier abord, est en réalité plus simple qu’il n’y paraît. Et une fois que l’on a compris l’intention derrière les attributs, on se surprend à les utiliser naturellement dans de nombreux cas.

Qu’est-ce qu’un attribut en PHP ?

Un attribut PHP est une sorte d’information supplémentaire que vous pouvez ajouter à un élément de code comme une classe, une propriété ou une méthode. Cette information ne change pas le fonctionnement direct du code, mais elle peut être lue par PHP ou par un outil externe (par exemple un framework) pour adapter le comportement du programme.

Si vous ne la maîtrisez pas encore, consulter notre tutoriel complet sur La POO en PHP.

Pour vulgariser un peu, imaginez que votre code soit un livre. L’attribut, c’est comme une petite note collée dans la marge. Le lecteur principal peut très bien ignorer cette note, mais quelqu’un d’autre peut l’utiliser pour comprendre le contexte, modifier un comportement ou automatiser une tâche.

Avant PHP 8, on utilisait souvent des commentaires spéciaux, appelés annotations. Elles étaient écrites sous forme de texte, analysées comme des chaînes de caractères, puis interprétées par certains frameworks. Cela fonctionnait, mais ce n’était pas très fiable. Avec les attributs, on passe dans quelque chose de beaucoup plus propre : du code compris directement par le moteur PHP, sans bricolage.

Voici un exemple très simple :

#[MonAttribut]
class Exemple {
}

Ici, #[MonAttribut] est un attribut appliqué à la classe Exemple. Bien sûr, cet attribut ne fera rien tant qu’il n’est pas défini quelque part. Mais la syntaxe est déjà claire, lisible, et standardisée.

Pourquoi PHP a introduit les attributs ?

Pour répondre à un besoin simple : arrêter de s’appuyer sur des commentaires pour stocker des informations structurées. Les commentaires, par définition, ne sont pas faits pour être interprétés par le moteur. Ils sont destinés aux humains. Pourtant, pendant longtemps, on en a détourné l’usage en les utilisant comme une sorte de langage parallèle.

Les attributs corrigent cela en permettant de :

1. Déclarer des métadonnées de manière native dans le langage.
2. Faciliter le travail des frameworks (Symfony, Laravel, Doctrine, etc.).
3. Rendre le code plus clair et plus maintenable.
4. Assurer une meilleure compatibilité des outils d’analyse automatique.

Avant, il fallait écrire :

/**
 * @Route("/accueil")
 */
function accueil() {
}

Aujourd’hui, on peut écrire :

#[Route('/accueil')]
function accueil() {
}

La différence peut sembler minime, mais elle est en réalité immense pour les outils qui utilisent ces données.

Syntaxe complète d’un attribut

Un attribut commence par #[ et se termine par ]. Il peut être placé au-dessus d’une classe, d’une méthode, d’une fonction, d’une propriété, et même d’un paramètre.

Voici un modèle complet :

#[NomAttribut(param1: "valeur", param2: 42)]
class Exemple {
    #[AutreAttribut]
    public string $nom;

    #[EncoreUnAttribut]
    public function faireQuelqueChose() {}
}

Vous pouvez également passer plusieurs attributs sur un même élément :

#[Premier, Second(param: "test")]
function calculer() {}

Si l’on compare cette écriture à un commentaire, on voit qu’elle est plus explicite, plus claire, et surtout mieux intégrée au langage.

Déclarer ses propres attributs

Un attribut n’existe pas tant qu’il n’est pas défini. Pour définir un attribut, il suffit de créer une classe avec l’attribut spécial #[Attribute].

Par exemple :

#[Attribute]
class Autorisation {
    public function __construct(public string $role) {}
}

On peut ensuite l’utiliser comme ceci :

#[Autorisation(role: 'admin')]
function supprimerUtilisateur() {
}

Cette simple ligne indique à votre application que cette fonction doit être réservée à un utilisateur administrateur. Bien sûr, il faudra du code pour interpréter cela, mais l’intention est désormais explicite.

L’attribut #[Override] en PHP 8.5

Passons maintenant à l’un des attributs les plus connus : #[Override].

Cet attribut PHP est utilisé quand vous redéfinissez une méthode dans une classe enfant. L’idée est d’indiquer clairement que vous remplacez une méthode existante. Si jamais la méthode n’existe pas dans le parent, PHP génère une erreur. Cela permet d’éviter une source classique de bugs : croire que l’on surcharge une méthode, alors qu’on crée en réalité une nouvelle méthode par erreur.

Considérez cet exemple :

class Animal {
    public function parler() {
        return "L'animal fait un bruit.";
    }
}

class Chien extends Animal {
    #[Override]
    public function parler() {
        return "Le chien aboie.";
    }
}

Grâce à #[Override], si vous faites une faute de frappe comme :

#[Override]
public function parlerr() {} 
// = erreur assurée

PHP vous avertira immédiatement. Sans cet attribut PHP, le code aurait été accepté et votre erreur serait passée inaperçue.

Cela peut sembler un détail, mais quand on travaille sur un gros projet (ou pire, un projet partagé avec d’autres développeurs), ce genre de faute est monnaie courante. Cet attribut améliore donc directement la fiabilité et la maintenabilité du code.

Il m’est arrivé de travailler sur une application où une classe faisait 1200 lignes. Oui, mille deux cents. À l’époque, on ne parlait pas encore de #[Override]. Une méthode avait été redéfinie plus bas dans le fichier, mais avec une faute dans son nom. Résultat : pendant des semaines, on pensait que la méthode du parent était utilisée… alors qu’on en avait écrit une nouvelle sans s’en rendre compte. Le bug était subtil : un comportement légèrement différent selon un cas précis. Nous avons perdu un temps considérable. Avec #[Override], PHP nous aurait alerté immédiatement. Et honnêtement, rien que pour ça, je suis très heureux que cette fonctionnalité soit là aujourd’hui.

Les autres attributs importants en PHP 8.5

PHP 8.5 ne se limite pas à #[Override]. Plusieurs autres attributs PHP sont devenus utiles au quotidien. Certains existaient déjà dans PHP 8.0, d’autres ont été améliorés ou mieux intégrés dans les usages. L’important est de comprendre leur intention avant de vouloir les utiliser.

Nous allons découvrir les attributs suivants :

• #[Deprecated]
• #[SensitiveParameter]
• #[NoReturn]
• #[\Attribute] (celui qui permet de définir des attributs)
• Quelques attributs introduits ou documentés avec plus de clarté depuis PHP 8.5

L’attribut #[Deprecated]

L’attribut #[Deprecated] permet de signaler que quelque chose dans votre code ne doit plus être utilisé. Cela peut être une fonction, une méthode, une classe, ou même une propriété. Cet attribut PHP est surtout utile quand vous travaillez sur un projet qui évolue dans le temps. Il sert à prévenir les autres développeurs qu’une fonctionnalité est vouée à disparaître.

Par exemple :

class Calculatrice {
    #[Deprecated("Utilisez la méthode addition() à la place.")]
    public function add($a, $b) {
        return $a + $b;
    }

    public function addition(int $a, int $b): int {
        return $a + $b;
    }
}

Si quelqu’un utilise la méthode add(), PHP affichera un avertissement pour les informer qu’il existe une alternative plus moderne.

Cet attribut permet donc d’accompagner l’évolution du code sans provoquer de rupture immédiate. Il laisse du temps aux développeurs d’adapter leurs habitudes.

L’attribut #[SensitiveParameter]

Cet attribut sert à indiquer qu’un paramètre contient une donnée sensible. Cela concerne les mots de passe, les jetons d’authentification, les données bancaires, etc. Lorsque cet attribut est utilisé, PHP évite d’afficher ces informations dans les logs ou les messages d’erreurs détaillés.

Exemple :

function connexion(string $username, #[SensitiveParameter] string $password) {
    // ...
}

Si votre application plante, PHP ne fera pas apparaître le mot de passe dans l’erreur. Cela peut éviter des catastrophes dans un environnement où les logs sont consultables par plusieurs personnes ou enregistrés sur un serveur distant.

Ce détail est essentiel pour renforcer la sécurité. Trop souvent, les erreurs affichent des informations confidentielles que personne n’aurait dû voir.

Des formations informatique pour tous !

Débutant ou curieux ? Apprenez le développement web, le référencement, le webmarketing, la bureautique, à maîtriser vos appareils Apple et bien plus encore…

Formateur indépendant, professionnel du web depuis 2006, je vous accompagne pas à pas et en cours particulier, que vous soyez débutant ou que vous souhaitiez progresser. En visio, à votre rythme, et toujours avec pédagogie.

Découvrez mes formations Qui suis-je ?

L’attribut #[NoReturn]

Cet attribut est utilisé sur une fonction ou une méthode qui, par nature, ne retourne jamais de valeur. Cela peut être parce qu’elle termine le script, redirige vers une autre page, ou lance systématiquement une exception.

Exemple :

#[NoReturn]
function erreurFatale(string $message): void {
    throw new Exception($message);
}

Cet attribut PHP aide les outils d’analyse statique et les développeurs à comprendre l’intention d’une méthode. Il clarifie votre code : dès que l’on voit #[NoReturn], on sait qu’il n’y aura pas de suite logique après l’appel.

L’attribut #[\Attribute] pour créer ses propres attributs

Nous l’avons déjà utilisé, mais il mérite un point d’éclairage. L’attribut #[\Attribute] permet d’indiquer que la classe que vous déclarez est utilisable comme attribut. Sans cela, PHP ne reconnaît pas votre classe comme pouvant être utilisée dans #[...].

Exemple plus détaillé :

#[\Attribute(\Attribute::TARGET_METHOD)]
class Journalisation {
    public function __construct(public string $niveau = 'info') {}
}

class Systeme {
    #[Journalisation('alerte')]
    public function redemarrer() {
        // ...
    }
}

Ici, \Attribute::TARGET_METHOD précise que Journalisation ne peut être appliqué qu’à des méthodes. Cela permet d’éviter de mauvaises utilisations, comme placer cet attribut au-dessus d’une classe ou d’une propriété par erreur.

Les valeurs possibles sont :

• TARGET_CLASS
• TARGET_METHOD
• TARGET_PROPERTY
• TARGET_FUNCTION
• TARGET_PARAMETER
• TARGET_ALL

Ces constantes permettent de contrôler la logique et de garder votre code expressif et clair.

Comment lire et exploiter les attributs dans son code ?

Déclarer des attributs PHP est une chose, mais à un moment donné, il faut bien les utiliser. C’est ici que l’API de réflexion de PHP entre en jeu. La réflexion permet de lire les métadonnées d’un élément de code. C’est grâce à elle que l’on peut analyser les attributs d’une classe, d’une méthode ou d’une propriété.

Voici un exemple simple de récupération d’attributs sur une méthode :

$ref = new ReflectionMethod(Systeme::class, 'redemarrer');
$attributes = $ref->getAttributes();

foreach ($attributes as $attr) {
    $instance = $attr->newInstance();
    echo $instance->niveau; // Affiche : alerte
}

Ici, getAttributes() renvoie la liste des attributs appliqués. On peut ensuite instancier chaque attribut pour accéder à ses valeurs internes. C’est une manière élégante de transmettre des instructions ou des paramètres à un système automatiquement.

Pourquoi les attributs PHP sont particulièrement utiles avec des frameworks

Vous avez peut-être remarqué que les exemples que nous avons vus ressemblent beaucoup à ce qui se fait dans des frameworks modernes comme Symfony, Laravel ou CodeIgniter. En effet, ce sont les frameworks qui tirent le plus parti des attributs.

Par exemple, dans Symfony, il est possible d’indiquer les routes directement dans les contrôleurs :

use Symfony\Component\Routing\Annotation\Route;

class ArticleController {
    #[Route('/articles')]
    public function index() {}
}

Plus besoin de configurer la route dans un fichier séparé. Le code devient plus facile à lire, à comprendre et à maintenir.

Dans Doctrine (ORM), les entités peuvent être configurées directement via des attributs plutôt que via des fichiers YAML ou XML. Dans Laravel, même si les attributs sont utilisés plus progressivement, on les voit déjà apparaître pour la validation ou l’automatisation des injections.

Plus les versions avancent, plus les attributs deviennent un langage commun et naturel, lisible même sans documentation.

Bonnes pratiques pour bien utiliser les attributs PHP

Comme toute fonctionnalité, il existe quelques principes à respecter :

• Ne pas utiliser les attributs pour tout. Ils sont puissants, mais doivent rester lisibles.
• Toujours utiliser #[Override] pour les méthodes surchargées. Cela évite des erreurs parfois très coûteuses.
• Utiliser #[Deprecated] pour organiser l’évolution du code. Un projet propre est un projet qui assume son histoire.
• Éviter de transformer les attributs en usine à gaz. S’ils deviennent trop complexes, ils perdent leur objectif principal : la clarté.

L’idée générale est simple : un attribut doit aider à comprendre, jamais à compliquer.

Intégrer les attributs dans un projet concret : un exemple pratique complet

Pour bien comprendre l’usage réel des attributs dans une application PHP moderne, prenons un cas courant : la gestion des permissions.

Imaginez que vous travaillez sur un site dans lequel certaines parties ne doivent être accessibles qu’à des utilisateurs administrateurs. Sans attributs, vous auriez peut-être l’habitude de faire cela dans chaque méthode concernée : vérifier le rôle, émettre une exception, etc.

Cela fonctionne, mais cela vous oblige à répéter du code. Et tout ce qui se répète finit tôt ou tard par provoquer une erreur, ou par devenir difficile à maintenir.

Avec les attributs, vous pouvez déclarer une règle une seule fois, et l’appliquer facilement.

Déclaration de l’attribut :

#[\Attribute(\Attribute::TARGET_METHOD)]
class RoleRequis {
    public function __construct(public string $role) {}
}

Utilisation dans votre contrôleur :

class TableauDeBord {
    #[RoleRequis('admin')]
    public function afficher() {
        echo "Bienvenue dans le tableau de bord.";
    }
}

Lecture et exécution automatique :

function executer(object $objet, string $methode) {
    $ref = new ReflectionMethod($objet, $methode);
    foreach ($ref->getAttributes(RoleRequis::class) as $attribut) {
        $instance = $attribut->newInstance();
        if ($_SESSION['role'] !== $instance->role) {
            die("Accès refusé");
        }
    }

    $objet->$methode();
}

session_start();
$_SESSION['role'] = 'utilisateur';
executer(new TableauDeBord(), 'afficher');

Dans cet exemple :

• Vous avez défini votre règle une seule fois.
• Vous l’avez appliquée en une ligne d’attribut.
• Le comportement est automatique, clair, sans duplication.

Cela montre toute la force des attributs : ils permettent d’exprimer l’intention du développeur avec précision.

Les attributs PHP et l’organisation du code : clarification de l’intention

Un bon code n’est pas seulement un code qui fonctionne. C’est un code que l’on peut comprendre en le lisant, sans devoir deviner ce qu’a voulu faire la personne qui l’a écrit.

Les attributs PHP vont exactement dans ce sens. Ils servent à rendre votre intention visible. Par exemple, #[Override] dit : cela remplace volontairement une méthode du parent. #[Deprecated] dit : ceci est encore utilisable, mais ne doit plus être utilisé. #[SensitiveParameter] dit : ce paramètre ne doit jamais apparaître en clair.

Ces attributs améliorent la lisibilité sans ajouter de logique. Ce sont des étiquettes claires, directes, assumées. On pourrait presque dire qu’ils rendent le code plus proche du langage humain.

Quand ne pas utiliser les attributs ?

Même si les attributs sont très pratiques, il est important de ne pas en abuser. Ils ne doivent pas remplacer la logique métier. Ils ne doivent pas devenir une couche magique invisible.

Par exemple, si vous utilisez des attributs pour faire des actions complexes, automatiques, qui ne sont visibles nulle part ailleurs dans votre code, vous risquez de surprendre d’autres développeurs… ou vous-même dans six mois.

Une règle simple et saine est de vous demander : « Cet attribut clarifie-t-il le code, ou le rend-il plus mystérieux ? »

Si la réponse penche vers le mystère, mieux vaut s’en passer.

Tableau récapitulatif des attributs PHP

Voici maintenant un tableau qui résume les principaux attributs PHP disponibles et utiles en PHP 8.5.

Ce tableau n’est pas exhaustif, mais il contient les attributs les plus utiles dans les projets réels en PHP 8.5.

Les attributs PHP sont l’une des évolutions les plus importantes du langage PHP depuis sa modernisation. Avec PHP 8.5, ils sont pleinement intégrés, robustes, cohérents, et surtout pensés pour rendre votre code plus clair et plus fiable. Ils permettent d’éviter des erreurs classiques, de documenter l’intention, d’organiser l’évolution d’un projet, et de rendre vos applications plus propres et plus maintenables.

Loin d’être une fonctionnalité réservée aux experts, les attributs peuvent être compris et utilisés dès les premiers projets, à condition de bien saisir leur logique : ils ne modifient pas directement le fonctionnement du code, mais ils fournissent au développeur et aux outils un langage commun pour décrire le comportement attendu.

Si vous débutez, commencez simple : utilisez #[Override], familiarisez-vous avec #[Deprecated] quand votre code évolue, et regardez comment votre framework préféré exploite les attributs. Vous verrez qu’au fil du temps, ils deviendront pour vous un réflexe naturel, comme ils le sont aujourd’hui dans la plupart des projets PHP modernes.

Alban

Fondateur de l’agence Créa-troyes.
Intervenant en Freelance.
Contactez-moi

crea-troyes.fr