PHP class library lookup table upgrade

PHP 5 has a full reflection API, adding the ability to reverse-engineer classes, interfaces, functions, methods, and extensions. In addition, the reflection API provides methods to retrieve documentation comments in functions, classes, and methods.

There are several types of reflections mentioned in the manual on the official website:

Reflection

ReflectionClass

ReflectionZendExtension

ReflectionExtension

ReflectionFunction

ReflectionFunctionAbstract

ReflectionMethod

ReflectionObject

ReflectionParameter

ReflectionProperty

ReflectionType

ReflectionGenerator

Reflector

ReflectionException

Tp5’s core classes are all in one directory

So I thought of glob traversal

 public function get_core_class(){
    $class_path = CORE_PATH;
    $before_cwd = getcwd();
    chdir($class_path);
    $names = glob('*.php');
    $ret = [];    foreach ($names as $key => $name) {
      $ret[] = 'think\\'. str_ireplace('.php', '', $name);
    }
    chdir($before_cwd);   return $ret;
  }Copy the code

The initialization of a reflection class passes the actual namespace path of the class.

$class= new\ReflectionClass($className); Like this. Then there are the following methods:

ReflectionClass: : __construct – initializes the ReflectionClass class ReflectionClass: : export – a derived class ReflectionClass: : getConstant – For defined a constant ReflectionClass: : ReflectionClass getConstants – to obtain a set of constants: : getConstructor – access to the constructor of a class ReflectionClass: : getDefaultProperties – get default attributes ReflectionClass: : getDocComment – get the document comment ReflectionClass: : getEndLine – For the last line of the number of rows ReflectionClass: : getExtension – according to the defined ReflectionClass class takes place extended ReflectionExtension object: : getExtensionName – For the expansion of the classes defined in the name of the ReflectionClass: : filename ReflectionClass getFileName – access to define the class: : getInterfaceNames – access interface (interface) name ReflectionClass: : getInterfaces – access interface ReflectionClass: : getMethod ReflectionMethod – get a class method. ReflectionClass ReflectionClass: : getMethods – acquisition method of array: : getModifiers – get the modifier ReflectionClass class: : getName – get the name of the class ReflectionClass: : getNamespaceName – for namespace name ReflectionClass: : getParentClass – get the superclass ReflectionClass: : getProperties – Get a set of attributes ReflectionClass: : getProperty – get a property of a class of ReflectionProperty ReflectionClass: : getShortName – for short name ReflectionClass: : getStartLine – get starting line number ReflectionClass: : getStaticProperties – get static properties (static) ReflectionClass: : getStaticPropertyValue – access to static (static) the value of the attribute ReflectionClass: : getTraitAliases – returns an array of trait alias ReflectionClass: : getTraitNames – returns the name of the traits of this class are using array ReflectionClass: : getTraits – returns the traits of the class by using an array ReflectionClass: : hasConstant – check to see if the constants has been defined ReflectionClass: : hasMethod – check methods defined ReflectionClass: : hasProperty – Check whether the attribute is defined ReflectionClass: : implementsInterface – the implementation of the interface ReflectionClass: : inNamespace – check whether in the namespace ReflectionClass: : isAbstract – check class is an abstract class (abstract) ReflectionClass: : isAnonymous – check whether class is an anonymous class ReflectionClass: : isCloneable – returns a class whether can copy the ReflectionClass: : isFinal – check whether the class is declared as final ReflectionClass: : isInstance – check the instance of the class ReflectionClass: : isInstantiable – check to see if the class can be instantiated ReflectionClass: : isInterface – check whether a class (interface) ReflectionClass: : isInternal – check whether the class is defined by the extension or core in internal ReflectionClass: : isIterateable – check whether can be iterative (iterateable) ReflectionClass: : isSubclassOf – check for a subclass ReflectionClass: : isTrait – returns whether it is a trait ReflectionClass: : isUserDefined – Check whether the ReflectionClass defined by the user: : newInstance – from the specified parameters to create a new class instance ReflectionClass: : newInstanceArgs – from the given parameters to create a new class instance. ReflectionClass: : newInstanceWithoutConstructor – create a new class instance and not call its constructor ReflectionClass: : setStaticPropertyValue – set the value of static properties ReflectionClass::__toString – Returns the string representation of the ReflectionClass object.

$class->getShortName(); $class->getShortName()

I mainly need to get the class shorthand name and method.

public function generate($classNames){ config('default_return_type', 'json'); $outputs = []; $outputs = []; $outputs = []; foreach ($classNames as $k => $className) { $class= new\ReflectionClass($className); $key = $class->getShortName(); // dump($key); $outputs[$key] = $this->getClassAnnotation($class); } return $outputs; }Copy the code

The getClassAnonation method is what I use to get information about all the methods of the class.

public function parseParameters($class, $method, $args){ if($args){ $args_str = []; foreach ($args as $key => $arg) { $p = new \ReflectionParameter(array($class, $method), $key); / / determine whether reference parameters the if ($p - > isPassedByReference ()) {$arg_str_new = "& \ $". $p - > getName (); }else{ $arg_str_new = "\$".$p->getName(); } if ($p->isOptional() && $p->isDefaultValueAvailable()) { $a_clsss = $class; $def = $p->getDefaultValue(); $def = $p->getDefaultValue(); $arg_str_new .= is_array($defaul) ? ' = '. '[]': ' = '. var_export($defaul, 1); }catch(\Exception $e){ trace($p->isVariadic()); trace($a_clsss.'/'.$method.'_'.$key); } } $args_str[] = $arg_str_new; } return implode(', ', $args_str); } return ''; }Copy the code

Some methods return null with no arguments, some with arguments, we want to concatenate the argument string like

<? phpclass A{ function foo($a){ } }Copy the code

PHP will not return foo($a). You have to deal with it yourself.

Check whether a parameter has a default value and is referenced

• getName

• isOptional

• isDefaultValueAvailable

• getDefaultValue

When I get the default value parameter, I find that sometimes exceptions are thrown, and they are always reported for inner classes.

So make sure you try and catch to get the default.

At this point, the whole function of obtaining the method and method annotation and parameter information of some classes is completely realized.

If you want to get a list of classes you just need to change the return value of get_CORE_class, as long as it’s a class that tp5 automatically loads. It’s all resolvable.

Overall idea, according to the class array to obtain method -> method document, obtain parameters -> obtain parameter information

In this way, I can feel relieved to be lazy. Next time TP upgrade, I will directly composer update, refresh the home page, and get static HTML update to my GH-Pages branch. This completes the update of the new framework sketch sheet.

Once and for all.