PHP-Reflection

Nette\Utils\Reflection ist eine statische Klasse mit nützlichen Funktionen für die PHP-Reflection. Ihr Zweck ist es, Schwächen der nativen Reflection-Klassen auszugleichen und das Verhalten über verschiedene PHP-Versionen hinweg zu vereinheitlichen.

Installation:

composer require nette/utils

Alle Beispiele setzen voraus, dass dieser Klassen-Alias definiert ist:

use Nette\Utils\Reflection;

areCommentsAvailable(): bool

Prüft, ob die Reflection Zugriff auf die PHPdoc-Kommentare hat. Die Kommentare können wegen des Cachings von Opcode fehlen, siehe zum Beispiel die Direktive opcache.save-comments.

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

Erweitert den Klassennamen $name im Kontext der Klasse $context zu seinem vollständig qualifizierten Namen und berücksichtigt dabei deren Namespace und die definierten Aliase. Im Grunde ermittelt sie, wie der PHP-Parser $name interpretieren würde, stünde er im Körper der Klasse $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

Gibt die Reflection der Methode zurück, die die tatsächliche Deklaration von $method enthält. Üblicherweise ist eine Methode ihre eigene Deklaration, der Körper der Methode kann aber aus einem Trait stammen und dort womöglich einen anderen Namen tragen.

Weil PHP nicht genug Informationen liefert, um die wahre Deklaration verlässlich zu bestimmen, verwendet Nette eine eigene Heuristik, die verlässlich sein sollte.

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

Gibt den Standardwert eines Parameters einer Funktion oder Methode zurück. Anders als das native ReflectionParameter::getDefaultValue() löst sie auch Konstanten und Klassenkonstanten korrekt auf, die als Standardwert verwendet werden. Lässt sich die Konstante nicht auflösen, wirft sie eine \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

Gibt die Reflection der Klasse oder des Traits zurück, die die Deklaration der Property $prop enthält. Die Property kann in einem Trait deklariert sein.

Weil PHP nicht genug Informationen liefert, um die wahre Deklaration verlässlich zu bestimmen, verwendet Nette eine eigene Heuristik, die nicht vollständig verlässlich ist.

trait DemoTrait
{
	public $foo;
}


class DemoClass
{
	use DemoTrait;
}

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

getUseStatements (ReflectionClass $class): array

Gibt ein Array der use-Anweisungen (Aliase) aus der Datei zurück, in der die Klasse $class definiert ist. Die Schlüssel sind die Aliase, die Werte die vollständig qualifizierten Klassennamen. Erfordert die PHP-Erweiterung 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

Prüft, ob $type ein in PHP eingebauter Typ ist. Andernfalls gilt er als Klassenname.

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

Verwenden Sie Nette\Utils\Validators::isBuiltinType().

toString ($reflection): string

Wandelt ein Reflection-Objekt in einen für Menschen lesbaren String um.

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