What are attributes (annotations) in PHP 8?

PHP 8 attributes add metadata to code elements in a structured way. 1. They are attached above classes, methods, etc. using #[] syntax, such as #[Route('/home')] to define routes; 2. It is safer than PHPDoc, with type checking and compile-time verification; 3. Custom attributes need to define classes and apply, such as using ReflectionAttribute to create LogExecution log attributes; 4. Commonly used in frameworks to handle routing, verification, ORM mapping and other tasks, improving code readability and separating logical configurations; 5. It can be accessed through reflection, but excessive use should be avoided to avoid affecting code clarity.

PHP 8 introduced a powerful new feature called attributes (also known as annotations in other languages ​​like Java or Python). They provide a structured and reusable way to add metadata to classes, methods, properties, functions, and more — all directly within the code using a clean syntax.

In short, attributes let you "attach" extra information to your code elements without affecting their logic. This can be used for things like routing in frameworks, validation rules, ORM mappings, and more.

What Do Attributes Look Like?

Attributes are written using the #[AttributeName] syntax placed above the element they annotate. Here's a basic example:

 #[Route('/home')]
function home() {
    echo 'Welcome!';
}

In this case, #[Route('/home')] is an attribute that tells some part of the application (like a router) how to handle the home() function.

You can also use multiple attributes:

 #[Cacheable]
#[Method('GET')]
function getData() {
    return fetchData();
}

Each attribute can have arguments passed to it, just like function calls. The exact meaning of those arguments depends on what the attribute does.

How Are Attributes Different from PHPDoc?

Before attributes, developers often used PHPDoc comments to achieve similar goals:

 /**
 * @Route("/home")
 * @Method("GET")
 */
function home() {
    // ...
}

While PHPDoc works, it has limitations:

• It's not type-safe — everything is a string.
• There's no enforcement of correct usage.
• You need to parse the comments manually or with tools.

Attributes solve these issues by being part of the language syntax. They're validated at compile time, support proper typing, and are easier to process programmatically.

How to Define and Use Custom Attributes

Creating your own attribute involves two steps: defining the attribute class and applying it somewhere.

Step 1: Define the Attribute Class

Use the Attribute class provided by PHP (from the ReflectionAttribute API):

 use Attribute;

#[Attribute]
class LogExecution {
    public function __construct(
        public string $message = 'Function executed'
    ) {}
}

This defines an attribute that can be attached to any element.

Step 2: Apply the Attribute

Now apply it to a function:

 #[LogExecution(message: 'User login function')]
function loginUser(string $username) {
    echo "Logging in $username\n";
}

Then, using reflection, you can read the attribute and do something useful — like log the message after the function runs.

Where Are Attributes Commonly Used?

Frameworks and libraries make heavy use of attributes because they allow clean separation between business logic and configuration.

Here are a few common use cases:

• Routing – Mapping URLs to controller methods
• Validation – Specifying data constraints for forms or APIs
• Serialization/Deserialization – Controlling how objects are converted to JSON or XML
• Dependency Injection – Marking services or injection points
• ORMs – Mapping database tables and columns to classes and properties

For example, in Symfony or Laravel, you might see something like:

 #[Route('/users/{id}', methods: ['GET'])]
public function show(int $id) {
    return User::find($id);
}

This tells the framework how to route incoming HTTP requests to this method.

A Few Things to Keep in Mind

• Attributes can target specific code elements using flags when defining them. For example, to only allow usage on functions:

   #[Attribute(Attribute::TARGET_FUNCTION)]

• You can access attributes via reflection ( ReflectionClass , ReflectionMethod , etc.) to read and act on them.

• While attributes are very flexible, overusing them can make your code harder to follow if not organized well.

• Not every project needs custom attributes — but they're super handy in larger applications or frameworks.

---

So yeah, PHP 8's attributes give us a modern, clean, and powerful way to work with metadata in our code. They're not hard to understand once you see how they fit into real-world examples — and they definitely beat parsing comments by hand.

The above is the detailed content of What are attributes (annotations) in PHP 8?. For more information, please follow other related articles on the PHP Chinese website!