PHP Reflexion

Nette\Utils\Reflection ist eine statische Klasse mit nützlichen Funktionen für die PHP-Reflexion. Ihre Aufgabe ist es, Mängel nativer Klassen zu beheben und das Verhalten über verschiedene PHP-Versionen hinweg zu vereinheitlichen.

Installation:

composer require nette/utils

Alle Beispiele setzen voraus, dass ein Alias erstellt wurde:

use Nette\Utils\Reflection;

areCommentsAvailable(): bool

Stellt fest, ob die Reflexion 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 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 Reflexion der Methode zurück, die die Deklaration der Methode $method enthält. Normalerweise ist jede Methode ihre eigene Deklaration, aber der Körper der Methode kann sich auch in einem Trait und unter einem anderen Namen befinden.

Da PHP nicht genügend Informationen bereitstellt, um die tatsächliche Deklaration zu ermitteln, 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 nicht genügend Informationen bereitstellt, um die tatsächliche Deklaration zu ermitteln, verwendet Nette eine 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

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'