PHP Reflection

Nette\Utils\Reflection est une classe statique contenant des fonctions utiles pour la réflexion PHP. Son but est de corriger les défauts des classes natives et d'unifier le comportement entre les différentes versions de PHP.

Installation :

composer require nette/utils

Tous les exemples supposent que l'alias de classe suivant est défini :

use Nette\Utils\Reflection;

areCommentsAvailable(): bool

Détermine si la réflexion a accès aux commentaires de PHPdoc. Les commentaires peuvent ne pas être disponibles à cause du cache opcode, voir par exemple la directive opcache.save-comments.

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

Étend le $name de la classe au nom complet dans le contexte du $context, c'est-à-dire dans le contexte de son espace de noms et des alias définis. Ainsi, il renvoie la manière dont l'analyseur PHP comprendrait $name s'il était écrit dans le corps de $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

Renvoie une réflexion d'une méthode qui contient une déclaration de $method. Habituellement, chaque méthode a sa propre déclaration, mais le corps de la méthode peut aussi se trouver dans le trait et sous un nom différent.

Comme PHP ne fournit pas assez d'informations pour déterminer la déclaration réelle, Nette utilise sa propre heuristique, qui devrait être fiable.

trait DemoTrait
{
	function foo()
	{
	}
}


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


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

getPropertyDeclaringClass(ReflectionProperty $prop): ReflectionClass

Renvoie une réflexion d'une classe ou d'un trait qui contient une déclaration de la propriété $prop. La propriété peut également être déclarée dans le trait.

Comme PHP ne fournit pas assez d'informations pour déterminer la déclaration réelle, Nette utilise sa propre heuristique, qui n'est pas fiable.

trait DemoTrait
{
	public $foo;
}


class DemoClass
{
	use DemoTrait;
}

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

isBuiltinType(string $type): bool

Détermine si $type est un type intégré à PHP. Sinon, c'est le nom de la classe.

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

Utilisez Nette\Utils\Validator::isBuiltinType().

toString($reflection): string

Convertit une réflexion en une chaîne de caractères lisible par l'homme.

$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'