PHP-Reflection
**************

.[perex]
[api: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:

```shell
composer require nette/utils
```

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

```php
use Nette\Utils\Reflection;
```


areCommentsAvailable(): bool .[method]
--------------------------------------

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|https://www.php.net/manual/en/opcache.configuration.php#ini.opcache.save-comments].


expandClassName(string $name, ReflectionClass $context): string .[method]
-------------------------------------------------------------------------

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`.

```php
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 .[method]
------------------------------------------------------------------------------

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**.

```php
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 .[method]
----------------------------------------------------------------------

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`.

```php
class DemoClass
{
	const DefaultValue = 123;
}

function demo($param = DemoClass::DefaultValue)
{
}

$param = new ReflectionParameter('demo', 'param');
echo Reflection::getParameterDefaultValue($param); // 123
```


getPropertyDeclaringClass(ReflectionProperty $prop): ReflectionClass .[method]
------------------------------------------------------------------------------

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.

```php
trait DemoTrait
{
	public $foo;
}


class DemoClass
{
	use DemoTrait;
}

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


getUseStatements(ReflectionClass $class): array .[method]
---------------------------------------------------------

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`.

```php
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 .[method deprecated]
------------------------------------------------------

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

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

.[note]
Verwenden Sie [Nette\Utils\Validators::isBuiltinType() |validators#isBuiltinType()].


toString($reflection): string .[method]
---------------------------------------

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

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