PHP Attributes, introduced in PHP 8.0, allow developers to add metadata to classes, methods, properties, and parameters in a structured and readable manner. Attributes are a modern alternative to PHPDoc comments and other annotation methods, offering a built-in, native way to describe and process metadata.

1. What Are PHP Attributes?

PHP Attributes provide a way to attach additional information (metadata) to code elements. These attributes can then be accessed at runtime using Reflection API.

Before PHP 8.0, developers typically used PHPDoc comments for metadata, like this:

/**
 * @Route("/home")
 */

However, this approach had limitations:

• PHPDoc is not enforced by PHP itself.
• Parsing requires external tools like Doctrine or PHPStan.

With PHP Attributes, the same metadata can be defined using a native syntax:

#[Route("/home")]

2. Syntax of PHP Attributes

PHP attributes are defined using #[] (hash and square brackets) before a declaration. They can be applied to:

• Classes
• Methods
• Properties
• Constants
• Function parameters

Example:

#[Attribute]
class Route {
    public function __construct(public string $path) {}
}

#[Route("/home")]
class HomeController {
    // Class logic
}

3. Declaring and Using PHP Attributes

To create a custom attribute in PHP, you must define a class with the #[Attribute] declaration.

3.1 Creating a Custom Attribute

Here's how you define a custom attribute:

#[Attribute]
class Route {
    public function __construct(public string $path) {}
}

• The #[Attribute] syntax marks the class as an attribute.
• The constructor allows passing parameters when the attribute is used.

3.2 Applying an Attribute

Once defined, an attribute can be applied to different code elements.

Applying to a Class

#[Route("/dashboard")]
class DashboardController {
    // Controller logic
}

Applying to a Method

class UserController {
    #[Route("/user/profile")]
    public function profile() {
        // Profile logic
    }
}

Applying to a Property

class User {
    #[SensitiveData]
    public string $password;
}

Applying to a Function Parameter

class APIController {
    public function fetchData(#[Validate] string $input) {
        // Fetching logic
    }
}

4. Attribute Targets

Attributes can be restricted to specific elements using Attribute::TARGET_* constants.

Available Targets:

Example: Restricting an Attribute to Methods Only

#[Attribute(Attribute::TARGET_METHOD)]
class CustomMethodAttribute {
    public function __construct(public string $message) {}
}

Now, if you try to use this attribute on a class or property, PHP will throw an error.

5. Reflection API: Retrieving Attributes at Runtime

Attributes are not just for decoration; they can be accessed at runtime using PHP's Reflection API.

5.1 Retrieving Class Attributes

$reflection = new ReflectionClass(HomeController::class);
$attributes = $reflection->getAttributes();

foreach ($attributes as $attribute) {
    $instance = $attribute->newInstance();
    echo $instance->path; // Output: "/home"
}

5.2 Retrieving Method Attributes

$reflection = new ReflectionMethod(UserController::class, 'profile');
$attributes = $reflection->getAttributes();

foreach ($attributes as $attribute) {
    $instance = $attribute->newInstance();
    echo $instance->path; // Output: "/user/profile"
}

5.3 Retrieving Property Attributes

$reflection = new ReflectionProperty(User::class, 'password');
$attributes = $reflection->getAttributes();

foreach ($attributes as $attribute) {
    echo get_class($attribute->newInstance()); // Output: SensitiveData
}

6. Built-in PHP Attributes

PHP provides some built-in attributes that serve special purposes.

6.1 #[Attribute]

Marks a class as an attribute.

#[Attribute]
class ExampleAttribute {}

6.2 #[Deprecated]

Marks a function, class, or method as deprecated.

class Test {
    #[Deprecated("Use newMethod() instead")]
    public function oldMethod() {}
}

6.3 #[Override] (PHP 8.2)

Ensures that a method is overriding a parent method.

class ParentClass {
    public function greet() {}
}

class ChildClass extends ParentClass {
    #[Override]
    public function greet() {}
}

If no method exists in the parent class, PHP throws an error.

6.4 #[SensitiveParameter] (PHP 8.2)

Marks a function parameter as sensitive, preventing it from appearing in stack traces.

function login(#[SensitiveParameter] string $password) {
    // Handle login
}

7. Multiple Attributes on a Single Element

You can use multiple attributes by separating them with commas inside #[].

#[Route("/home"), Deprecated]
class HomeController {}

8. Attribute Inheritance

By default, attributes are not inherited. To enable inheritance, use Attribute::IS_REPEATABLE | Attribute::IS_INHERITED.

#[Attribute(Attribute::TARGET_CLASS | Attribute::IS_INHERITED)]
class ParentAttribute {}

#[ParentAttribute]
class Base {}

class Child extends Base {}

Now, Child will also have ParentAttribute.

9. Repeating Attributes

Attributes can be repeatable by adding Attribute::IS_REPEATABLE.

#[Attribute(Attribute::IS_REPEATABLE)]
class Permission {
    public function __construct(public string $role) {}
}

#[Permission("admin"), Permission("editor")]
class Dashboard {}

Now, Dashboard has two Permission attributes.

PHP Attributes introduce a powerful, type-safe way to define metadata in your applications. They replace PHPDoc annotations with a native, structured syntax, improving readability and maintainability.

Key Takeaways:

• Attributes provide structured metadata in PHP.
• They can be applied to classes, methods, properties, and parameters.
• Use the Reflection API to access attribute data at runtime.
• Attributes can be restricted, inherited, and repeated for flexibility.
• PHP has built-in attributes like #[Deprecated], #[Override], and #[SensitiveParameter].

By leveraging attributes, PHP developers can write cleaner, more maintainable, and more structured code.