Reflexión de PHP

Nette\Utils\Reflection es una clase estática con funciones útiles para la reflexión de PHP. Su propósito es cubrir las carencias de las clases nativas de reflexión y unificar el comportamiento entre las distintas versiones de PHP.

Instalación:

composer require nette/utils

Todos los ejemplos suponen que está definido el siguiente alias de clase:

use Nette\Utils\Reflection;

areCommentsAvailable(): bool

Comprueba si la reflexión tiene acceso a los comentarios phpDoc. Los comentarios pueden no estar disponibles por culpa del cacheado de opcode, vea por ejemplo la directiva opcache.save-comments.

expandClassName (string $name, ReflectionClass $context): string

Expande el nombre de clase $name a su nombre pleno dentro del contexto de la clase $context, teniendo en cuenta su espacio de nombres y los alias definidos. En esencia, determina cómo interpretaría el analizador de PHP el nombre $name si estuviera escrito dentro del cuerpo de la clase $context.

namespace Foo;
use Bar;

class DemoClass
{
	// new Bar, new Baz
}

$context = new ReflectionClass(Foo\DemoClass::class);
Reflection::expandClassName('Bar', $context); // 'Bar'
Reflection::expandClassName('Baz', $context); // 'Foo\Baz'

getMethodDeclaringMethod (ReflectionMethod $method): ReflectionMethod

Devuelve la reflexión del método que contiene la declaración real de $method. Normalmente, un método es su propia declaración, pero el cuerpo del método puede proceder de un trait y, eventualmente, con otro nombre.

Como PHP no aporta información suficiente para determinar la declaración real de forma fiable, Nette usa sus propias heurísticas, que deberían ser fiables.

trait DemoTrait
{
	function foo()
	{
	}
}


class DemoClass
{
	use DemoTrait {
		DemoTrait::foo as foo2;
	}
}


$method = new ReflectionMethod('DemoClass::foo2');
Reflection::getMethodDeclaringMethod($method); // ReflectionMethod('DemoTrait::foo')

getParameterDefaultValue (\ReflectionParameter $param): mixed

Devuelve el valor predeterminado de un parámetro de función o método. A diferencia del nativo ReflectionParameter::getDefaultValue(), también resuelve correctamente las constantes y las constantes de clase usadas como valor predeterminado. Si la constante no se puede resolver, lanza \ReflectionException.

class DemoClass
{
	const DefaultValue = 123;
}

function demo($param = DemoClass::DefaultValue)
{
}

$param = new ReflectionParameter('demo', 'param');
echo Reflection::getParameterDefaultValue($param); // 123

getPropertyDeclaringClass (ReflectionProperty $prop): ReflectionClass

Devuelve la reflexión de la clase o del trait que contiene la declaración de la propiedad $prop. La propiedad puede estar declarada dentro de un trait.

Como PHP no aporta información suficiente para determinar la declaración real de forma fiable, Nette usa sus propias heurísticas, que no son del todo fiables.

trait DemoTrait
{
	public $foo;
}


class DemoClass
{
	use DemoTrait;
}

$prop = new ReflectionProperty(DemoClass::class, 'foo');
Reflection::getPropertyDeclaringClass($prop); // ReflectionClass('DemoTrait')

getUseStatements (ReflectionClass $class): array

Devuelve un array con las sentencias use (alias) del archivo en el que está definida la clase $class. Las claves son los alias y los valores, los nombres plenos de las clases. Requiere la extensión tokenizer de PHP.

namespace Foo;

use Nette\Utils\Strings;
use Nette\Utils\Arrays as Arr;

class DemoClass
{
}

$class = new ReflectionClass(Foo\DemoClass::class);
Reflection::getUseStatements($class);
// ['Strings' => 'Nette\Utils\Strings', 'Arr' => 'Nette\Utils\Arrays']

isBuiltinType (string $type): bool

Comprueba si $type es un tipo nativo de PHP. En caso contrario, se considera un nombre de clase.

Reflection::isBuiltinType('string'); // true
Reflection::isBuiltinType('Foo');    // false

Use Nette\Utils\Validators::isBuiltinType().

toString ($reflection): string

Convierte un objeto de reflexión en una cadena legible para el ser humano.

$func = new ReflectionFunction('func');
echo Reflection::toString($func); // 'func()'

$class = new ReflectionClass('DemoClass');
echo Reflection::toString($class); // 'DemoClass'

$method = new ReflectionMethod('DemoClass', 'foo');
echo Reflection::toString($method); // 'DemoClass::foo()'

$param = new ReflectionParameter(['DemoClass', 'foo'], 'param');
echo Reflection::toString($param); // '$param in DemoClass::foo()'

$prop = new ReflectionProperty('DemoClass', 'foo');
echo Reflection::toString($prop); // 'DemoClass::$foo'