PHP-Reflexion

Nette\Utils\Reflection ist eine statische Klasse mit nützlichen Funktionen für PHP Reflection. Ihr Zweck ist es, Fehler in nativen Klassen zu beheben und das Verhalten zwischen verschiedenen PHP-Versionen zu vereinheitlichen.

Installation:

composer require nette/utils

Alle Beispiele setzen voraus, dass der folgende Klassenalias definiert ist:

use Nette\Utils\Reflection;

areCommentsAvailable(): bool

Findet heraus, ob Reflection Zugriff auf PHPdoc-Kommentare hat. Kommentare können aufgrund des Opcode-Caches nicht verfügbar sein, siehe z.B. die Direktive opcache.save-comments.

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

Erweitert die $name der Klasse auf den vollen Namen im Kontext der $context, d.h. im Kontext ihres Namespace und der definierten Aliase. Er gibt also zurück, wie der PHP-Parser $name verstehen würde, wenn er im Body der $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 eine Reflexion einer Methode zurück, die eine Deklaration von $method enthält. Normalerweise ist jede Methode eine eigene Deklaration, aber der Körper der Methode kann auch im Trait und unter einem anderen Namen stehen.

Da PHP nicht genügend Informationen liefert, um die tatsächliche Deklaration zu bestimmen, verwendet Nette seine 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 eine Reflexion einer Klasse oder eines Traits zurück, die eine Deklaration der Eigenschaft $prop enthält. Die Eigenschaft kann auch im Trait deklariert werden.

Da PHP nicht genügend Informationen liefert, um die tatsächliche Deklaration zu bestimmen, verwendet Nette seine eigene Heuristik, die nicht 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

Ermittelt, ob $type ein in PHP eingebauter Typ ist. Andernfalls ist es der Klassenname.

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

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

toString($reflection): string

Konvertiert eine Reflexion in eine für Menschen lesbare Zeichenkette.

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