Understand the new features of PHP 8, Attributes annotations

The Alpha version of PHP8 will be released in a few days. It contains many new features. Of course, I think the most important one is JIT, which I started in 2013. After participating in numerous setbacks and failures, I finally want to release something.

However, today, I am not going to talk about JIT. After PHP8 is released, I will write a separate series similar to "In-depth Understanding of JIT in PHP8".

Hey, today, I want to talk about Attributes. Why? Yesterday I saw many groups forwarding an article called "Understanding Attributes in PHP8". To be honest, this article should It was translated directly from English and the writing was difficult to understand. After reading it, many students said they were confused and had no idea what they were talking about.

So I thought, I would use an article to briefly talk about what this is.

Before talking about annotations, let’s talk about the previous comments. We often see something like the following @param and @see in PHP projects:

/**
 * @param Foo $argument
 * @see https:/xxxxxxxx/xxxx/xxx.html
 */    
 function dummy($Foo) {}

This is called Comments, for previous PHP, the @param and @see in the comments are meaningless, and the entire paragraph will be saved as a string called doc_comment of a function/method.

If we want to analyze the meaning of this comment, we need to design some specific syntax, such as @ name in Lili, similar to @param, and then analyze this string ourselves to extract the corresponding information.

For example, if we want to obtain the information of the See comment, we need to do string processing like:

$ref = new ReflectionFunction("dummy");
$doc = $ref->getDocComment();
$see = substr($doc, strpos($doc, "@see") + strlen("@see "));

, which is relatively troublesome and error-prone.

As for Attributes, it actually upgrades "annotations" to supports formatted content "annotations"

For example, the above example:

<<Params("Foo", "argument")>>
<<See("https://xxxxxxxx/xxxx/xxx.html")>>
function dummy($argument) {}

Don’t worry about the meaning of writing this way. From a functional point of view, you can now obtain this formatted annotation through Reflection. For example, we now want to obtain the See annotation:

$ref = new ReflectionFunction("dummy");
 
var_dump($ref->getAttributes("See")[0]->getName());
var_dump($ref->getAttributes("See")[0]->getArguments());

will be output :

string(3) "See"
array(1) {
  [0]=>
  string(30) "https://xxxxxxxx/xxxx/xxx.html"
}

Of course, there is a slightly more advanced usage, that is, you can define a so-called "annotation class":

<?php
<<phpAttribute>>
class MyAttribute {
     public function __construct($name, $value) {
          var_dump($name);
          var_dumP($value);
     }
}

Then, you can write something like, pay attention to the newInstance call in it :

<<MyAttribute("See", "https://xxxxxxxx/xxxx/xxx.html")>>
function dummy($argument) {
}
$ref = new ReflectionFunction("dummy");
 
$ref->getAttributes("MyAttribute")[0]->newInstance();

If you run this code, you will see that the __construct method of MyAttribute is called, and the parameters passed in the call are "See" and "https://xxx"

Do you understand? You can "instantiate" an annotation, and then you can make your own "annotation-as-configuration" design based on this capability. To sum up, the writing method of Attributes is as follows:

<<Name>>
<<Name(Arguments)>>
<<Name(Argunment1, Arguments2, ArgumentN)>>
 
<<Name1(Argument), Name2(Argument), Name3(Argument)>>

Then you can get the corresponding annotations according to getAttributes ("Name") through PHP's Reflection series methods. Further, you can call the returned annotations. The getName method gets the name, and the getArguments method gets the Arguments in parentheses.

Furthermore, if Name is a class you define yourself with phpAttriubtes annotations, you can also call the newInstance method to implement a call similar to "new Name (Arguments)".

Perhaps many people will ask, what is the use of this?

To be honest, I have always been indifferent to new features, but this Attributes should still have a little bit.

Recommended article: "PHP8.0"

The above is the detailed content of Understand the new features of PHP 8, Attributes annotations. For more information, please follow other related articles on the PHP Chinese website!