Réflexion PHP

Nette\Utils\Reflection est une classe statique avec des fonctions utiles pour la réflexion PHP. Sa tâche est de corriger les lacunes des classes natives et d'unifier le comportement à travers différentes versions de PHP.

Installation :

composer require nette/utils

Tous les exemples supposent qu'un alias a été créé :

use Nette\Utils\Reflection;

areCommentsAvailable(): bool

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

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

Développe le nom de classe $name en son nom complet dans le contexte de la classe $context, c'est-à-dire dans le contexte de son espace de noms et des alias définis. Donc, en fait, il indique comment l'analyseur PHP comprendrait $name s'il était écrit dans le corps de la classe $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

Retourne la réflexion de la méthode qui contient la déclaration de la méthode $method. Habituellement, chaque méthode est sa propre déclaration, mais le corps de la méthode peut se trouver aussi dans un trait et sous un autre nom.

Parce que PHP ne fournit pas d'informations suffisantes avec lesquelles on peut 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')

getParameterDefaultValue (\ReflectionParameter $param): mixed

Retourne la valeur par défaut d'un paramètre de fonction ou de méthode. Contrairement à la méthode native ReflectionParameter::getDefaultValue(), elle résout aussi correctement les constantes et les constantes de classe utilisées comme valeur par défaut. Si la constante ne peut pas être résolue, elle lève une \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

Retourne la réflexion de la classe ou du trait qui contient la déclaration de la propriété $prop. La propriété peut en effet être déclarée aussi dans un trait.

Parce que PHP ne fournit pas d'informations suffisantes avec lesquelles on peut 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')

getUseStatements (ReflectionClass $class): array

Retourne un tableau des instructions use (alias) du fichier dans lequel la classe $class est définie. Les clés sont les alias, les valeurs les noms de classes pleinement qualifiés. Nécessite l'extension PHP tokenizer.

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

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

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

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

toString ($reflection): string

Convertit la réflexion en une chaîne compréhensible 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'