PHP ReflectionFunction::getClosureScopeClass方法代码示例

 /**
  * Recursively traverses and wraps all Closure objects within the value.
  *
  * NOTE: THIS MAY NOT WORK IN ALL USE CASES, SO USE AT YOUR OWN RISK.
  *
  * @param mixed $data Any variable that contains closures.
  * @param SerializerInterface $serializer The serializer to use.
  */
 public static function wrapClosures(&$data, SerializerInterface $serializer)
 {
     if ($data instanceof \Closure) {
         // Handle and wrap closure objects.
         $reflection = new \ReflectionFunction($data);
         if ($binding = $reflection->getClosureThis()) {
             self::wrapClosures($binding, $serializer);
             $scope = $reflection->getClosureScopeClass();
             $scope = $scope ? $scope->getName() : 'static';
             $data = $data->bindTo($binding, $scope);
         }
         $data = new SerializableClosure($data, $serializer);
     } elseif (is_array($data) || $data instanceof \stdClass || $data instanceof \Traversable) {
         // Handle members of traversable values.
         foreach ($data as &$value) {
             self::wrapClosures($value, $serializer);
         }
     } elseif (is_object($data) && !$data instanceof \Serializable) {
         // Handle objects that are not already explicitly serializable.
         $reflection = new \ReflectionObject($data);
         if (!$reflection->hasMethod('__sleep')) {
             foreach ($reflection->getProperties() as $property) {
                 if ($property->isPrivate() || $property->isProtected()) {
                     $property->setAccessible(true);
                 }
                 $value = $property->getValue($data);
                 self::wrapClosures($value, $serializer);
                 $property->setValue($data, $value);
             }
         }
     }
 }

 /**
  * Checks if callable is bindable.
  *
  * @param \Closure $callable
  * @return bool
  */
 function isBindable(Closure $callable)
 {
     $bindable = false;
     $reflectionFunction = new \ReflectionFunction($callable);
     if ($reflectionFunction->getClosureScopeClass() === null || $reflectionFunction->getClosureThis() !== null) {
         $bindable = true;
     }
     return $bindable;
 }

 /**
  * Hash anything, return the unique identity.
  *
  * @param $object
  * @return string
  */
 protected function hash($object)
 {
     array_walk_recursive($object, function (&$item) {
         if ($item instanceof \Closure) {
             $reflection = new \ReflectionFunction($item);
             $item = serialize($reflection->getClosureScopeClass()) . $reflection->getNumberOfParameters() . $reflection->getNamespaceName() . $reflection->getStartLine() . $reflection->getEndLine();
         }
     });
     return md5(serialize($object));
 }

 /**
  * Hash anything (except PDO connection stuff, for now).
  *
  * @param mixed $object
  * @return string
  */
 public static function hash($object)
 {
     $object = is_array($object) ? $object : [$object];
     array_walk_recursive($object, function ($item) {
         if ($item instanceof \Closure) {
             $reflection = new \ReflectionFunction($item);
             // Unique and fast.
             $item = serialize($reflection->getClosureScopeClass()) . $reflection->getNumberOfParameters() . $reflection->getNamespaceName() . $reflection->getStartLine() . $reflection->getEndLine();
         }
     });
     return md5(serialize($object));
 }

 /**
  * Creates a ClosureLocation and seeds it with all the data that can be gleaned from the closure's reflection
  *
  * @param \ReflectionFunction $reflection The reflection of the closure that this ClosureLocation should represent
  *
  * @return ClosureLocation
  */
 public static function fromReflection(\ReflectionFunction $reflection)
 {
     $location = new self();
     $location->directory = dirname($reflection->getFileName());
     $location->file = $reflection->getFileName();
     $location->function = $reflection->getName();
     $location->line = $reflection->getStartLine();
     // @codeCoverageIgnoreStart
     if (version_compare(PHP_VERSION, '5.4', '>=')) {
         $closureScopeClass = $reflection->getClosureScopeClass();
         $location->closureScopeClass = $closureScopeClass ? $closureScopeClass->getName() : null;
     }
     // @codeCoverageIgnoreEnd
     return $location;
 }

 public function afterTraverse(array $nodes)
 {
     if ($this->location['class']) {
         $this->location['class'] = $this->location['namespace'] . '\\' . $this->location['class'];
         $this->location['method'] = "{$this->location['class']}::{$this->location['function']}";
     } elseif ($this->location['trait']) {
         $this->location['trait'] = $this->location['namespace'] . '\\' . $this->location['trait'];
         $this->location['method'] = "{$this->location['trait']}::{$this->location['function']}";
     }
     if (!$this->location['class']) {
         /** @var \ReflectionClass $closureScopeClass */
         $closureScopeClass = $this->reflection->getClosureScopeClass();
         $this->location['class'] = $closureScopeClass ? $closureScopeClass->getName() : null;
     }
 }

 public static function unwrap(\Closure $closure)
 {
     $reflectionFunction = new \ReflectionFunction($closure);
     if (substr($reflectionFunction->getName(), -1) === '}') {
         $vars = $reflectionFunction->getStaticVariables();
         return isset($vars['_callable_']) ? $vars['_callable_'] : $closure;
     } else {
         if ($obj = $reflectionFunction->getClosureThis()) {
             return [$obj, $reflectionFunction->getName()];
         } else {
             if ($class = $reflectionFunction->getClosureScopeClass()) {
                 return [$class->getName(), $reflectionFunction->getName()];
             }
         }
     }
     return $reflectionFunction->getName();
 }

 public function afterTraverse(array $nodes)
 {
     if ($this->location['class']) {
         $this->location['class'] = $this->location['namespace'] . '\\' . $this->location['class'];
         $this->location['method'] = "{$this->location['class']}::{$this->location['function']}";
     } elseif ($this->location['trait']) {
         $this->location['trait'] = $this->location['namespace'] . '\\' . $this->location['trait'];
         $this->location['method'] = "{$this->location['trait']}::{$this->location['function']}";
         // If the closure was declared in a trait, then we will do a best
         // effort guess on the name of the class that used the trait. It's
         // actually impossible at this point to know for sure what it is.
         if ($closureScope = $this->reflection->getClosureScopeClass()) {
             $this->location['class'] = $closureScope ? $closureScope->getName() : null;
         } elseif ($closureThis = $this->reflection->getClosureThis()) {
             $this->location['class'] = get_class($closureThis);
         }
     }
 }

 /**
  * @param callable $listener
  *
  * @return string
  */
 private function getControllerName($listener) : string
 {
     if (is_array($listener)) {
         if (is_string($listener[0])) {
             return $listener[0] . '::' . $listener[1];
         } else {
             return get_class($listener[0]) . '::' . $listener[1];
         }
     } elseif (is_string($listener)) {
         return $listener;
     } else {
         $reflection = new \ReflectionFunction($listener);
         return $reflection->getClosureScopeClass()->getName() . '::' . 'closure[' . $reflection->getStartLine() . ':' . $reflection->getEndLine() . ']';
     }
 }

<?php

$c = function () {
    var_dump($this);
};
$d = $c->bindTo(new stdClass());
$d();
$rm = new ReflectionFunction($d);
var_dump($rm->getClosureScopeClass()->name);
//dummy sope is Closure
//should have the same effect
$d = $c->bindTo(new stdClass(), NULL);
$d();
$rm = new ReflectionFunction($d);
var_dump($rm->getClosureScopeClass()->name);
//dummy sope is Closure
echo "Done.\n";

<?php

$closure = function ($param) {
    return "this is a closure";
};
$rf = new ReflectionFunction($closure);
var_dump($rf->getClosureScopeClass());
class A
{
    public static function getClosure()
    {
        return function ($param) {
            return "this is a closure";
        };
    }
}
$closure = A::getClosure();
$rf = new ReflectionFunction($closure);
var_dump($rf->getClosureScopeClass());
echo "Done!\n";