Attributes is a language feature introduced in PHP 8 that allows appending metadata to code elements through the syntax of #[Attribute]. 1. It is essentially an instance of a class, which can be used in classes, methods, functions, parameters, etc.; 2. It is often used in routing definitions, verification rules, ORM mappings, permission control and other scenarios; 3. Use the reflection API to read Attribute information and instantiate it. For example, after defining a Route class and appending it to a function, you can obtain the output of path information through reflection. Attributes improves code structure clarity and configuration concentration.

In modern PHP, Attributes is a mechanism used to add metadata to classes, methods, functions, parameters, etc. They allow you to attach additional information to your code in a structured, clear way that can be read and used at runtime. This is a bit like annotations, but is more powerful and more native.

What are Attributes?

Attributes is a language feature introduced in PHP 8 that allows you to mark code elements through the syntax of #[Attribute] . It is essentially an instance of a class that can be attached to various code structures, such as classes, methods, properties, functions and even parameters.

Let's give a simple example:

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

In this example, #[Route("/home")] is an Attribute, which appends a routing information to home() function.

Basic usage of Attributes

To use Attributes, you need to define a class with #[Attribute] first, and then you can use it elsewhere.

Define an Attribute class

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

This class can now be used as an Attribute.

Use on a function or method

 #[Route("/about")]
function showAbout() {
    echo "About page";
}

You can read this information through reflection, such as checking whether a function has Route property and obtaining its path.

Common uses and actual scenarios

PHP's Attributes are mainly used in the following aspects:

• Routing definition : Many frameworks such as Symfony and Laravel have begun to replace traditional annotation configurations with Attributes.
• Verification rules : For example, use Attributes to mark whether the field is required and whether the format is legal.
• ORM mapping : ORM frameworks such as Doctrine use Attributes to map database tables and fields.
• Permission Control : Can be used to mark which user roles can access specific methods.

For example, in Laravel 9 you can write a controller like this:

 use Illuminate\Routing\Controller;

class PostController extends Controller {
    #[Middleware("auth")]
    public function create() {
        // Only logged in users can execute}
}

How to read Attributes?

If you implement a set of Attributes-based logic yourself, you need to use the reflection API.

Here is a simple example showing how to read an Attribute on a function:

 $reflection = new ReflectionFunction('showAbout');
foreach ($reflection->getAttributes() as $attribute) {
    if ($attribute->getName() === 'Route') {
        $route = $attribute->newInstance();
        echo "Path: " . $route->path;
    }
}

This code will output: Path: /about .

What should be noted is:

• To use a full namespace, such as \Attribute
• If you define Attribute classes in namespace, you should also pay attention to correct references when using them.
• Some frameworks have encapsulated the Attribute processing logic and do not require manual reflection operation.

Basically that's it. Attributes is a very practical feature. Although it seems to be just a tag, the scalability behind it is very strong. As long as the design is reasonable, the code can be clearer and the configuration can be more concentrated.

The above is the detailed content of What are Attributes in modern php and how are they used?. For more information, please follow other related articles on the PHP Chinese website!