PHP ReflectionFunction::getStaticVariables方法代码示例

 /**
  * @link http://php.net/manual/en/serializable.serialize.php
  */
 public function serialize()
 {
     // prepare code
     $file = new SplFileObject($this->reflection->getFileName());
     $file->seek($this->reflection->getStartLine() - 1);
     $code = '';
     while ($file->key() < $this->reflection->getEndLine()) {
         $code .= $file->current();
         $file->next();
     }
     $start = strpos($code, 'function');
     $code = substr($code, $start, strpos($code, '}') - $start + 1);
     // prepare variables
     $variables = [];
     $index = stripos($code, 'use');
     // if 'use' keyword found
     if (false !== $index) {
         // get the names of the variables inside the use statement
         $start = strpos($code, '(', $index) + 1;
         $end = strpos($code, ')', $start);
         $use_variables = explode(',', substr($code, $start, $end - $start));
         $static_variables = $this->reflection->getStaticVariables();
         // keep only the variables that appeared in both scopes
         foreach ($use_variables as $variable) {
             $variable = trim($variable, '$&');
             $variables[$variable] = $static_variables[$variable];
         }
     }
     return serialize(['code' => $code, 'variables' => $variables]);
 }

 public function view()
 {
     $services = array();
     $bindings = Core::getBindings();
     foreach ($bindings as $name => $binding) {
         /** @var \Closure $binding */
         $reflection = new \ReflectionFunction($binding['concrete']);
         $static = $reflection->getStaticVariables();
         $className = null;
         if (!isset($static['concrete'])) {
             try {
                 $class = Core::make($name);
                 $className = get_class($class);
             } catch (\Exception $e) {
             }
         } else {
             $className = $static['concrete'];
         }
         if ($className !== null && $className !== get_class($this)) {
             if ($className[0] !== '\\') {
                 $className = '\\' . $className;
             }
             $services[$name] = array('class' => $className);
         }
     }
     ksort($services);
     $this->set('services', $services);
 }

 public function parse(&$variable)
 {
     if (!$variable instanceof Closure) {
         return false;
     }
     $this->name = 'Closure';
     $reflection = new ReflectionFunction($variable);
     $ret = array('Parameters' => array());
     if ($val = $reflection->getParameters()) {
         foreach ($val as $parameter) {
             // todo http://php.net/manual/en/class.reflectionparameter.php
             $ret['Parameters'][] = $parameter->name;
         }
     }
     if ($val = $reflection->getStaticVariables()) {
         $ret['Uses'] = $val;
     }
     if (method_exists($reflection, 'getClousureThis') && ($val = $reflection->getClosureThis())) {
         $ret['Uses']['$this'] = $val;
     }
     if ($val = $reflection->getFileName()) {
         $this->value = Kint::shortenPath($val) . ':' . $reflection->getStartLine();
     }
     return $ret;
 }

 /**
  * Returns an associative array containing this function's static variables
  * and their values
  *
  * @return array<sting,mixed> This function's static variables
  */
 public function getStaticVariables()
 {
     if ($this->reflectionSource instanceof ReflectionFunction) {
         return $this->reflectionSource->getStaticVariables();
     } else {
         return parent::getStaticVariables();
     }
 }

function dumpFuncInfo($name)
{
    $funcInfo = new ReflectionFunction($name);
    var_dump($funcInfo->getName());
    var_dump($funcInfo->isInternal());
    var_dump($funcInfo->isUserDefined());
    var_dump($funcInfo->getStartLine());
    var_dump($funcInfo->getEndLine());
    var_dump($funcInfo->getStaticVariables());
}

 public function render()
 {
     $file = '<?php namespace PHPSTORM_META { $STATIC_METHOD_TYPES = array(\\Core::make(\'\') => array(' . PHP_EOL;
     $legacyHelpers = array();
     $bindings = Core::getBindings();
     foreach ($bindings as $name => $binding) {
         /** @var \Closure $binding */
         $reflection = new \ReflectionFunction($binding['concrete']);
         $static = $reflection->getStaticVariables();
         $className = null;
         if (!isset($static['concrete'])) {
             try {
                 $class = Core::make($name);
                 if (is_object($class)) {
                     $className = get_class($class);
                 }
             } catch (\Exception $e) {
             }
         } else {
             $className = $static['concrete'];
         }
         if ($className !== null && $className !== get_class($this)) {
             if ($className[0] !== '\\') {
                 $className = '\\' . $className;
             }
             $file .= '\'' . $name . '\' instanceof ' . $className . ',' . PHP_EOL;
             if (substr($name, 0, 7) === 'helper/') {
                 $legacyHelpers[substr($name, 7)] = $className;
             }
         }
     }
     $app = Core::make('app');
     $reflection = new \ReflectionClass($app);
     $instances = $reflection->getProperty("instances");
     $instances->setAccessible(true);
     // :)
     foreach ($instances->getValue($app) as $name => $instance) {
         if (!isset($bindings[$name])) {
             $className = get_class($instance);
             $file .= '\'' . $name . '\' instanceof ' . $className . ',' . PHP_EOL;
         }
     }
     $file .= '), \\Loader::helper(\'\') => array(';
     foreach ($legacyHelpers as $legacyHelper => $className) {
         $file .= '\'' . $legacyHelper . '\' instanceof ' . $className . ',' . PHP_EOL;
     }
     $file .= '), \\Package::getByHandle(\'\') => array(';
     $packages = \Package::getAvailablePackages(false);
     foreach ($packages as $package) {
         /** @var \Package $package */
         $file .= '\'' . $package->getPackageHandle() . '\' instanceof \\' . get_class($package) . ',' . PHP_EOL;
     }
     $file .= '));}';
     return $file;
 }

 public function makeId(\Closure $callback)
 {
     $ref = new \ReflectionFunction($callback);
     $file = new \SplFileObject($ref->getFileName());
     $file->seek($ref->getStartLine() - 1);
     $content = '';
     while ($file->key() < $ref->getEndLine()) {
         $content .= $file->current();
         $file->next();
     }
     return sha1(json_encode(array($content, $ref->getStaticVariables(), $ref->getFileName(), $ref->getStartLine() - 1, $ref->getEndLine())));
 }

 /**
  * Get the variables used by the Closure.
  *
  * @return array
  */
 public function getVariables()
 {
     if (!$this->getUseIndex()) {
         return array();
     }
     $staticVariables = $this->reflection->getStaticVariables();
     // When looping through the variables, we will only take the variables that are
     // specified in the use clause, and will not take any other static variables
     // that may be used by the Closures, allowing this to re-create its state.
     $usedVariables = array();
     foreach ($this->getUseClauseVariables() as $variable) {
         $variable = trim($variable, ' $&');
         $usedVariables[$variable] = $staticVariables[$variable];
     }
     return $usedVariables;
 }

 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();
 }

 private function verifyCallbackJob($callback, LinkTarget $expectedTitle, $expectedUserId, callable $notificationTimestampCondition)
 {
     $this->assertInternalType('callable', $callback);
     $callbackReflector = new ReflectionFunction($callback);
     $vars = $callbackReflector->getStaticVariables();
     $this->assertArrayHasKey('job', $vars);
     $this->assertInstanceOf(ActivityUpdateJob::class, $vars['job']);
     /** @var ActivityUpdateJob $job */
     $job = $vars['job'];
     $this->assertEquals($expectedTitle->getDBkey(), $job->getTitle()->getDBkey());
     $this->assertEquals($expectedTitle->getNamespace(), $job->getTitle()->getNamespace());
     $jobParams = $job->getParams();
     $this->assertArrayHasKey('type', $jobParams);
     $this->assertEquals('updateWatchlistNotification', $jobParams['type']);
     $this->assertArrayHasKey('userid', $jobParams);
     $this->assertEquals($expectedUserId, $jobParams['userid']);
     $this->assertArrayHasKey('notifTime', $jobParams);
     $this->assertTrue($notificationTimestampCondition($jobParams['notifTime']));
 }

 /**
  * Format static (used) variable names.
  *
  * @param \Closure $value
  *
  * @return string
  */
 protected function formatStaticVariables(\Closure $value)
 {
     $r = new \ReflectionFunction($value);
     $used = $r->getStaticVariables();
     if (empty($used)) {
         return '';
     }
     $names = array_map(array($this, 'formatParamName'), array_keys($used));
     return sprintf(self::USE_FMT, implode(', ', $names));
 }

<?php

function dummy()
{
    static $a = array();
}
class Test
{
    const A = 0;
    public function func()
    {
        static $a = array(self::A => 'a');
    }
}
$reflect = new ReflectionFunction("dummy");
print_r($reflect->getStaticVariables());
$reflect = new ReflectionMethod('Test', 'func');
print_r($reflect->getStaticVariables());

 /**
  * Dump an object
  *
  * @param   mixed         $var    Variable to dump
  * @param   KObjectConfig $config The configuration options
  * @param   integer       $level  Current recursion level (internal usage only)
  * @return  string
  */
 protected function _dumpObject($var, KObjectConfig $config, $level = 0)
 {
     $fields = $this->_getObjectVars($var);
     if ($var instanceof Closure) {
         $rc = new ReflectionFunction($var);
         $fields = array();
         foreach ($rc->getParameters() as $param) {
             $fields[] = '$' . $param->getName();
         }
         $fields = array('file' => $rc->getFileName(), 'line' => $rc->getStartLine(), 'variables' => $rc->getStaticVariables(), 'parameters' => implode(', ', $fields));
     }
     if ($var instanceof SplFileInfo) {
         $fields = array('path' => $var->getPathname());
     }
     if ($var instanceof SplObjectStorage) {
         $fields = array();
         foreach (clone $var as $obj) {
             $fields[] = array('object' => $obj, 'data' => $var[$obj]);
         }
     }
     if ($var instanceof KObjectInterface) {
         unset($fields['__methods']);
     }
     if ($var instanceof KObjectManager) {
         $fields = array();
     }
     if ($var instanceof KObjectConfigInterface) {
         $fields = $var->toArray();
     }
     $result = '';
     $result .= '<span class="koowa-dump-object">' . get_class($var) . '</span>';
     if ($var instanceof KObjectInterface) {
         $result .= '<span class="koowa-dump-identifier">(' . $var->getIdentifier() . ')</span>';
     }
     $result .= '<span class="koowa-dump-hash">#' . substr(md5(spl_object_hash($var)), 0, 4) . '</span>';
     static $list = array();
     if (!empty($fields)) {
         if (!in_array($var, $list, true)) {
             if ($level < $config->object_depth || $var instanceof Closure) {
                 $collapsed = $level ? count($var) >= 7 : false;
                 $result = '<span class="koowa-toggle' . ($collapsed ? ' koowa-collapsed' : '') . '">' . $result . '</span>';
                 $result .= '<div' . ($collapsed ? ' class="koowa-collapsed"' : '') . '>';
                 $list[] = $var;
                 foreach ($fields as $key => $value) {
                     $vis = '';
                     if ($key[0] === "") {
                         $vis = ' <span class="koowa-dump-visibility">' . ($key[1] === '*' ? 'protected' : 'private') . '</span>';
                         $key = substr($key, strrpos($key, "") + 1);
                     }
                     $result .= '<span class="koowa-dump-indent">   ' . str_repeat('|  ', $level) . '</span>';
                     $result .= '<span class="koowa-dump-key">' . (preg_match('#^\\w+\\z#', $key) ? $key : $this->getTemplate()->escape($key)) . '</span> ' . $vis . ' => ';
                     $result .= $this->_dumpVar($value, $config, $level + 1);
                 }
                 array_pop($list);
                 $result .= '</div>';
             } else {
                 $result .= ' { ... }' . "\n";
             }
         } else {
             $result .= ' { <i>RECURSION</i> }' . "\n";
         }
     } else {
         $result .= "\n";
     }
     return $result;
 }

 /**
  * cache function result and return it
  * @param $function closure to cache 
  * @return object     
  */
 public function cacheFun($function)
 {
     if ($this->getConfig('debug') && !is_callable($function)) {
         echo "no valid function";
     }
     $r = new ReflectionFunction($function);
     $id = null;
     foreach ($r->getStaticVariables() as $key => $var) {
         if ($key == 'key') {
             $id = $var;
         }
     }
     if (is_object($id)) {
         $id = $this->getIDfromOjb($id);
     }
     if ($id == null && $this->getConfig('debug')) {
         echo "no caching key";
         return $function();
     }
     $cachefile = $this->getConfig('cacheDir') . '/' . utf8_decode($id);
     $cachetime = $this->getConfig('cacheTime');
     if (file_exists($cachefile) && time() - $cachetime < fileatime($cachefile)) {
         $ser = file_get_contents($cachefile);
         $val = bzdecompress(unserialize($ser));
         return $val;
     } else {
         $value = $function();
         $ser = serialize(bzcompress($value));
         file_put_contents($cachefile, $ser);
         return $value;
     }
     if ($this->getConfig('debug')) {
         echo "no caching";
     }
 }

 /**
  * Get a memory usage breakdown
  * @return array
  */
 function getMemoryBreakdown()
 {
     $memStats = array();
     foreach ($GLOBALS as $name => $value) {
         $memStats['$' . $name] = strlen(serialize($value));
     }
     $classes = get_declared_classes();
     foreach ($classes as $class) {
         $rc = new ReflectionClass($class);
         $props = $rc->getStaticProperties();
         $memStats[$class] = strlen(serialize($props));
         $methods = $rc->getMethods();
         foreach ($methods as $method) {
             $memStats[$class] += strlen(serialize($method->getStaticVariables()));
         }
     }
     $functions = get_defined_functions();
     foreach ($functions['user'] as $function) {
         $rf = new ReflectionFunction($function);
         $memStats["{$function}()"] = strlen(serialize($rf->getStaticVariables()));
     }
     asort($memStats);
     return $memStats;
 }