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 annotations. 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 were meaningless, and the entire paragraph would 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 get 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" tosupports formatted content"annotations"
For example, the above example:
> <> 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":
> 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 ：
<> 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 summarize, the way to write Attributes is in the following form:
<> <> <>
Then you can use PHP’s Reflection series of methods to get the corresponding annotations based on getAttributes("Name"). Further, you can Get the name by calling the getName method of the returned annotation, and get the Arguments in parentheses with the getArguments method.
Furthermore, if Name is a class you define yourself with phpAttriubtes annotation, 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?
Frankly speaking, I have always been indifferent to new features, but this Attributes should still have a little bit
Recommended tutorial: "PHP》
The above is the detailed content of PHP8 new features: Attributes. For more information, please follow other related articles on the PHP Chinese website!
