PHP Reflexion

Nette\Utils\Reflection ist eine statische Klasse mit Hilfsfunktionen für die PHP-Reflexion. Ihre Aufgabe ist es, Unzulänglichkeiten der nativen Reflexionsklassen zu beheben und das Verhalten über verschiedene PHP-Versionen hinweg zu vereinheitlichen.

Installation:

composer require nette/utils

Alle Beispiele setzen voraus, dass der folgende Alias definiert wurde:

use Nette\Utils\Reflection;

areCommentsAvailable(): bool

Prüft, ob die Reflexion Zugriff auf PHPdoc-Kommentare hat. Kommentare sind möglicherweise aufgrund des Opcode-Caches nicht verfügbar (siehe z.B. die Direktive opcache.save-comments).

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

Erweitert den Klassennamen $name zu seinem vollständigen Namen im Kontext der Klasse $context, d.h. im Kontext ihres Namensraums und der definierten Aliase. Es sagt also eigentlich, wie der PHP-Parser $name verstehen würde, wenn er im Körper der Klasse $context geschrieben wäre.

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 ReflectionMethod der Methode zurück, die die ursprüngliche Deklaration von $method enthält. Normalerweise ist jede Methode ihre eigene Deklaration, aber der Methodenrumpf kann sich auch in einem Trait befinden und die Methode unter einem anderen Namen (Alias) verwendet werden.

Da PHP keine ausreichenden Informationen zur Ermittlung der tatsächlichen Deklaration bereitstellt, verwendet Nette eine eigene Heuristik, die zuverlässig 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')

getPropertyDeclaringClass (ReflectionProperty $prop): ReflectionClass

Gibt die Reflexion der Klasse oder des Traits zurück, die die Deklaration der Eigenschaft $prop enthält. Eine Eigenschaft kann nämlich auch in einem Trait deklariert sein.

Da PHP keine ausreichenden Informationen zur Ermittlung der tatsächlichen Deklaration bereitstellt, verwendet Nette eine eigene Heuristik, die jedoch nicht immer zuverlässig ist.

trait DemoTrait
{
	public $foo;
}


class DemoClass
{
	use DemoTrait;
}

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

isBuiltinType (string $type): bool

Stellt fest, ob $type ein eingebauter PHP-Typ ist. Andernfalls handelt es sich um einen Klassennamen.

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

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

toString ($reflection): string

Konvertiert eine Reflexion in einen für Menschen lesbaren String.

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