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 dit 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')

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

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'