Reflection::getModifierNames
Unserialized reflection class cause error.
<?php
/**
* abc
*/
class a{}
$ref = new ReflectionClass('a');
$ref = unserialize(serialize($ref));
var_dump($ref);
var_dump($ref->getDocComment());
// object(ReflectionClass)#2 (1) {
// ["name"]=>
// string(1) "a"
// }
// PHP Fatal error: ReflectionClass::getDocComment(): Internal error: Failed to retrieve the reflection object
?>
The ReflectionClass class
(PHP 5)
Introduction
The ReflectionClass class reports information about a class.
Class synopsis
ReflectionClass
implements
Reflector
{
/* Constants */
/* Properties */
public
$name
;
/* Methods */
__construct
( mixed
}$argument
)Properties
- name
-
Name of the class. Read-only, throws ReflectionException in attempt to write.
Predefined Constants
Table of Contents
- ReflectionClass::__construct — Constructs a ReflectionClass
- ReflectionClass::export — Exports a class
- ReflectionClass::getConstant — Gets defined constant
- ReflectionClass::getConstants — Gets constants
- ReflectionClass::getConstructor — Gets the constructor of the class
- ReflectionClass::getDefaultProperties — Gets default properties
- ReflectionClass::getDocComment — Gets doc comments
- ReflectionClass::getEndLine — Gets end line
- ReflectionClass::getExtension — Gets a ReflectionExtension object for the extension which defined the class
- ReflectionClass::getExtensionName — Gets the name of the extension which defined the class
- ReflectionClass::getFileName — Gets the filename of the file in which the class has been defined
- ReflectionClass::getInterfaceNames — Gets the interface names
- ReflectionClass::getInterfaces — Gets the interfaces
- ReflectionClass::getMethod — Gets a ReflectionMethod for a class method.
- ReflectionClass::getMethods — Gets an array of methods
- ReflectionClass::getModifiers — Gets modifiers
- ReflectionClass::getName — Gets class name
- ReflectionClass::getNamespaceName — Gets namespace name
- ReflectionClass::getParentClass — Gets parent class
- ReflectionClass::getProperties — Gets properties
- ReflectionClass::getProperty — Gets a ReflectionProperty for a class's property
- ReflectionClass::getShortName — Gets short name
- ReflectionClass::getStartLine — Gets starting line number
- ReflectionClass::getStaticProperties — Gets static properties
- ReflectionClass::getStaticPropertyValue — Gets static property value
- ReflectionClass::getTraitAliases — Returns an array of trait aliases
- ReflectionClass::getTraitNames — Returns an array of names of traits used by this class
- ReflectionClass::getTraits — Returns an array of traits used by this class
- ReflectionClass::hasConstant — Checks if constant is defined
- ReflectionClass::hasMethod — Checks if method is defined
- ReflectionClass::hasProperty — Checks if property is defined
- ReflectionClass::implementsInterface — Implements interface
- ReflectionClass::inNamespace — Checks if in namespace
- ReflectionClass::isAbstract — Checks if class is abstract
- ReflectionClass::isCloneable — Returns whether this class is cloneable
- ReflectionClass::isFinal — Checks if class is final
- ReflectionClass::isInstance — Checks class for instance
- ReflectionClass::isInstantiable — Checks if the class is instantiable
- ReflectionClass::isInterface — Checks if the class is an interface
- ReflectionClass::isInternal — Checks if class is defined internally by an extension, or the core
- ReflectionClass::isIterateable — Checks if iterateable
- ReflectionClass::isSubclassOf — Checks if a subclass
- ReflectionClass::isTrait — Returns whether this is a trait
- ReflectionClass::isUserDefined — Checks if user defined
- ReflectionClass::newInstance — Creates a new class instance from given arguments.
- ReflectionClass::newInstanceArgs — Creates a new class instance from given arguments.
- ReflectionClass::newInstanceWithoutConstructor — Creates a new class instance without invoking the constructor.
- ReflectionClass::setStaticPropertyValue — Sets static property value
- ReflectionClass::__toString — Returns the string representation of the ReflectionClass object.
add a note
User Contributed Notes
ReflectionClass - [4 notes]
Anonymous ¶
1 year ago
danbettles at yahoo dot co dot uk ¶
4 years ago
To reflect on a namespaced class in PHP 5.3, you must always specify the fully qualified name of the class - even if you've aliased the containing namespace using a "use" statement.
So instead of:
<?php
use App\Core as Core;
$oReflectionClass = new ReflectionClass('Core\Singleton');
?>
You would type:
<?php
use App\Core as Core;
$oReflectionClass = new ReflectionClass('App\Core\Singleton');
?>
thecelavi at gmail dot com ¶
3 years ago
Right:
<?php
use AppCore as Core;
$oReflectionClass = new ReflectionClass('App\Core\Singleton');
?>
Wrong:
<?php
use AppCore as Core;
$oReflectionClass = new ReflectionClass('\App\Core\Singleton');
?>
snx ¶
10 months ago
if you want to use an object method as a callback parameter for any asynchronous action you have to transfer the reflection method and the object itself.
consider doing something like this:
<?php
class Callback extends ReflectionMethod{
protected $oObject;
public function __construct($oObject, $sMethod){
parent::__construct($oObject, $sMethod);
$this->oObject = $oObject;
$this->setAccessible(true); //to access even protected methods..
}
public function invoke(){
$this->invokeArgs($this->oObject, func_get_args());
}
}
?>
now you can easy create an reflector for the specific object method and pass it to any function...
<?php
class ClassA{
public function doSomething(){
$oCallback = new Callback($this, '_asyncCallback');
doAsyncCall($oCallback);
}
protected function _asyncCallback(...){
//...
}
}
function doAsyncCall($oCallback){
$oCallback->invoke(...);
}
?>