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');
?>
Clase ReflectionClass
(PHP 5, PHP 7, PHP 8)
Introducción
La clase ReflectionClass devuelve información sobre una clase.
Sinopsis de la Clase
Propiedades
- name
-
Nombre de la clase. De sólo lectura, lanza una ReflectionException en el intento de escribir.
Constantes predefinidas
Tabla de contenidos
- ReflectionClass::__construct — Construye un objeto de tipo ReflectionClass
- ReflectionClass::export — Exporta una clase
- ReflectionClass::getAttributes — Gets Attributes
- ReflectionClass::getConstant — Obtener una constante definida
- ReflectionClass::getConstants — Obtener constantes
- ReflectionClass::getConstructor — Obtiene el constructor de una clase
- ReflectionClass::getDefaultProperties — Obtener propiedades predeterminadas
- ReflectionClass::getDocComment — Obtener los comentarios de documentación
- ReflectionClass::getEndLine — Consultar línea final
- ReflectionClass::getExtension — Obtiene un objeto ReflectionExtension para la extensión que definió la clase
- ReflectionClass::getExtensionName — Obtiene el nombre de la extensión que definió una clase
- ReflectionClass::getFileName — Obtiene el nombre de fichero en el que está definida la clase
- ReflectionClass::getInterfaceNames — Obtiene nombres de las interfaces
- ReflectionClass::getInterfaces — Obtiene las interfaces
- ReflectionClass::getMethod — Obtiene un objeto ReflectionMethod para un método de una clase
- ReflectionClass::getMethods — Obtiene un array de métodos
- ReflectionClass::getModifiers — Obtiene los modificadores de clase
- ReflectionClass::getName — Obtiene el nombre de la clase
- ReflectionClass::getNamespaceName — Obtiene el nombre del espacio de nombres
- ReflectionClass::getParentClass — Obtiene la clase padre
- ReflectionClass::getProperties — Obtiene las propiedades
- ReflectionClass::getProperty — Obtiene un objeto ReflectionProperty para una propiedad de una clase
- ReflectionClass::getReflectionConstant — Gets a ReflectionClassConstant for a class's constant
- ReflectionClass::getReflectionConstants — Gets class constants
- ReflectionClass::getShortName — Obtiene el nombre abreviado
- ReflectionClass::getStartLine — Obtiene el número de linea de inicio
- ReflectionClass::getStaticProperties — Obtiene las propiedades estáticas
- ReflectionClass::getStaticPropertyValue — Obtiene el valor de una propiedad estática
- ReflectionClass::getTraitAliases — Obtiene un array con los alias usados con los traits
- ReflectionClass::getTraitNames — Devuelve un array con los nombres de los traits usados por esta clase
- ReflectionClass::getTraits — Obtiene un array con los traits que utiliza esta clase
- ReflectionClass::hasConstant — Comprueba si una constante está o no definida
- ReflectionClass::hasMethod — Comprueba si un método está o no definido
- ReflectionClass::hasProperty — Comprueba si una propiedad está o no definida
- ReflectionClass::implementsInterface — Comprueba si se implementa una determinada interfaz
- ReflectionClass::inNamespace — Comprueba si pertenece a un determinado espacio de nombres
- ReflectionClass::isAbstract — Comprueba si la clase es abstracta
- ReflectionClass::isAnonymous — Checks if class is anonymous
- ReflectionClass::isCloneable — Comprueba si la clase es o no clonable
- ReflectionClass::isEnum — Returns whether this is an enum
- ReflectionClass::isFinal — Comprueba si la clase inal
- ReflectionClass::isInstance — Comprueba si un objeto es instancia de la clase
- ReflectionClass::isInstantiable — Comprueba si una clase es instanciable
- ReflectionClass::isInterface — Comprueba una la clase es una interfaz
- ReflectionClass::isInternal — Comprueba si una clase está definida internamente por una extensión o por el núcleo
- ReflectionClass::isIterable — Check whether this class is iterable
- ReflectionClass::isIterateable — Comprueba si es iterable
- ReflectionClass::isReadOnly — Checks if class is readonly
- ReflectionClass::isSubclassOf — Comprueba si es una subclase
- ReflectionClass::isTrait — Comprueba si es un trait
- ReflectionClass::isUserDefined — Comprueba si es una clase definida por el usuario
- ReflectionClass::newInstance — Crea una nueva instancia de clase a partir de la lista de parámetros dados
- ReflectionClass::newInstanceArgs — Crea una nueva instancia de clase a partir de los argumentos dados
- ReflectionClass::newInstanceWithoutConstructor — Crea una nueva clase sin invocar al constructor
- ReflectionClass::setStaticPropertyValue — Establece el valor de una propiedad estática
- ReflectionClass::__toString — Devuelve la representación en forma de string del objeto ReflectionClass
add a note
User Contributed Notes 5 notes
danbettles at yahoo dot co dot uk ¶
15 years ago
Anonymous ¶
11 years ago
Reflecting an alias will give you a reflection of the resolved class.
<?php
class X {
}
class_alias('X','Y');
class_alias('Y','Z');
$z = new ReflectionClass('Z');
echo $z->getName(); // X
?>
Anonymous ¶
13 years ago
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
?>
featherbits ¶
3 years ago
In order to get class attributes look here (php8)
https://www.php.net/manual/en/language.attributes.reflection.php
YoungOfCthulhu ¶
9 years ago
It is also possible to do reflection from within the class and get the methods for instance.
<?php
class test
{
private $test = "";
public function setTest($test)
{
$this->test = $test;
return $this;
}
public function getTest()
{
return $this->test;
}
public function run(){
$class = new ReflectionClass('test');
$methods = $class->getMethods();
var_dump($methods);
}
}
Called from another php file you get the proper result:
array(3) {
[0]=>
&object(ReflectionMethod)#3 (2) {
["name"]=>
string(8) "setTest"
["class"]=>
string(4) "test"
}
[1]=>
&object(ReflectionMethod)#4 (2) {
["name"]=>
string(8) "getTest"
["class"]=>
string(4) "test"
}
[2]=>
&object(ReflectionMethod)#5 (2) {
["name"]=>
string(3) "run"
["class"]=>
string(4) "test"
}
}
