PHP ReflectionParameter::__toString方法代码示例

 public function __construct(ReflectionParameter $param)
 {
     if (method_exists('ReflectionParameter', 'getType')) {
         if ($type = $param->getType()) {
             $this->type_hint = (string) $type;
         }
     } else {
         if ($param->isArray()) {
             $this->type_hint = 'array';
         } else {
             try {
                 if ($this->type_hint = $param->getClass()) {
                     $this->type_hint = $this->type_hint->name;
                 }
             } catch (ReflectionException $e) {
                 preg_match('/\\[\\s\\<\\w+?>\\s([\\w]+)/s', $param->__toString(), $matches);
                 $this->type_hint = isset($matches[1]) ? $matches[1] : '';
             }
         }
     }
     $this->reference = $param->isPassedByReference();
     $this->position = $param->getPosition();
     $this->name = $param->getName();
     if ($param->isDefaultValueAvailable()) {
         $this->default = var_export($param->getDefaultValue(), true);
     }
 }

 /**
  * Returns a string representation
  * @return string
  */
 public function __toString()
 {
     if ($this->parameter) {
         return $this->parameter->__toString();
     } else {
         return parent::__toString();
     }
 }

 /**
  * Representation of the object
  *
  * If an exception is caught, its message is returned instead of the
  * original result (but it is not thrown ahead).
  *
  * @return string
  */
 public function __toString()
 {
     try {
         return parent::__toString() . ' with user value { ' . ReflectionValue::export($this->value, true) . ' }';
     } catch (\Exception $e) {
         return $e->__toString();
     }
 }

 /**
  * Returns the type of the parameter. In case the parameter has no type (e.g. primitive) the
  * method returns null. 
  * 
  * @param ReflectionParameter $param
  * @return string
  */
 public static function getParameterType(ReflectionParameter $param)
 {
     $matches = array();
     preg_match('/\\[\\s\\<\\w+?>\\s([\\w]+)/s', $param->__toString(), $matches);
     if (isset($matches[1])) {
         return $matches[1];
     } else {
         return null;
     }
 }

 /**
  * @return ReflectionTypeInterface|null
  */
 public function getType()
 {
     if (PHP_MAJOR_VERSION >= 7) {
         if ($this->hasType()) {
             return new ReflectionType($this->parameter->getType());
         } else {
             return null;
         }
     }
     $type = null;
     preg_match('/\\[\\s<\\w+?>\\s([\\\\\\w]+)/', $this->parameter->__toString(), $matches);
     if (isset($matches[1])) {
         if (in_array($matches[1], ReflectionTypeInterface::NON_QUALIFIED_TYPES, true)) {
             $name = $matches[1];
         } else {
             $name = '\\' . $matches[1];
         }
         $type = new ReflectionTypePolyFill($name, $this->parameter->allowsNull());
     }
     return $type;
 }

 /**
  * Gets the argument data type
  *
  * Returns same data types as PHP's gettype() method:
  *  'boolean', 'integer', 'double', 'string', 'array',
  *  'object', 'resource', 'NULL', 'unknown type'
  *
  * @param    \ReflectionParameter $argument Argument's ReflectionParameter instance
  * @return    string
  */
 private function getArgumentType(\ReflectionParameter $argument)
 {
     if ($argument->isArray()) {
         return 'array';
     }
     // check to see if it's a typehinted class
     $regex = '/^.*\\<\\w+?> ([\\w\\\\]+?) +.*$/';
     preg_match($regex, $argument->__toString(), $matches);
     if (isset($matches[1])) {
         return 'object';
     }
     if ($argument->isOptional()) {
         return gettype($argument->getDefaultValue());
     }
     return null;
 }

 /**
  * A static version of `ReflectionParameter::getName()` that doesn't require the parameter class to be loaded.
  *
  * This prevents fatal errors when a parameter uses a class name for type hinting but the class is not loaded.
  *
  * @param  \ReflectionParameter $param The parameter reflection object
  * @return string                      The name of the parameter's type hinted object, if there is one.
  */
 protected static function getParameterClassName(\ReflectionParameter $param)
 {
     preg_match('/\\[\\s\\<\\w+?>\\s([a-zA-Z0-9_\\\\]+)/s', $param->__toString(), $matches);
     return isset($matches[1]) ? $matches[1] : null;
 }

 public static final function getParameterType(ReflectionParameter $param)
 {
     preg_match('/\\[\\s\\<\\w+?>\\s([\\w]+)/s', $param->__toString(), $matches);
     return isset($matches[1]) ? $matches[1] : null;
 }

 protected function getClassName(ReflectionParameter $param)
 {
     preg_match('/\\[\\s\\<\\w+?>\\s([\\w]+)/s', $param->__toString(), $matches);
     return isset($matches[1]) ? $matches[1] : null;
 }

 protected function getParameterClassName(\ReflectionParameter $param)
 {
     preg_match('/> ([^ ]+) /', $param->__toString(), $matches);
     return !in_array($matches[1], ['$' . $param->getName(), 'array'], true) ? $matches[1] : null;
 }

 private function getParamClassName(\ReflectionParameter $param)
 {
     preg_match('/\\[\\s\\<\\w+?>\\s([\\w\\\\]+)/s', $param->__toString(), $matches);
     return isset($matches[1]) ? $matches[1] : null;
 }

<?php

function foo(array $x = array('a', 'b'))
{
}
$r = new ReflectionParameter('foo', 0);
echo $r->__toString();

 private static function getClassName(\ReflectionParameter $param)
 {
     preg_match('/(\\w+)\\s\\$\\w+\\s\\]$/s', $param->__toString(), $matches);
     return isset($matches[1]) ? $matches[1] : null;
 }