Reflection di PHP

Nette\Utils\Reflection è una classe statica che offre utili funzioni per la reflection di PHP. Il suo scopo è colmare le lacune delle classi native di reflection e uniformare il comportamento tra le diverse versioni di PHP.

Installazione:

composer require nette/utils

Tutti gli esempi presuppongono che sia definito questo alias di classe:

use Nette\Utils\Reflection;

areCommentsAvailable(): bool

Controlla se la reflection ha accesso ai commenti PHPdoc. I commenti possono non essere disponibili a causa della cache degli opcode, vedi per esempio la direttiva opcache.save-comments.

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

Espande il nome di classe $name nel suo nome pienamente qualificato nel contesto della classe $context, tenendo conto del suo namespace e degli alias definiti. In sostanza stabilisce come il parser di PHP interpreterebbe $name se fosse scritto nel corpo della classe $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

Restituisce la reflection del metodo che contiene la dichiarazione effettiva di $method. Di norma un metodo è la propria dichiarazione, ma il corpo del metodo può provenire da un trait ed eventualmente avere un nome diverso.

Poiché PHP non fornisce informazioni sufficienti per determinare in modo affidabile la vera dichiarazione, Nette usa una propria euristica, che dovrebbe essere affidabile.

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

Restituisce il valore predefinito di un parametro di funzione o di metodo. A differenza del nativo ReflectionParameter::getDefaultValue(), risolve correttamente anche le costanti e le costanti di classe usate come valore predefinito. Se la costante non si può risolvere, solleva una \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

Restituisce la reflection della classe o del trait che contiene la dichiarazione della proprietà $prop. La proprietà può essere dichiarata dentro un trait.

Poiché PHP non fornisce informazioni sufficienti per determinare in modo affidabile la vera dichiarazione, Nette usa una propria euristica, che non è del tutto affidabile.

trait DemoTrait
{
	public $foo;
}


class DemoClass
{
	use DemoTrait;
}

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

getUseStatements (ReflectionClass $class): array

Restituisce un array delle istruzioni use (gli alias) del file in cui è definita la classe $class. Le chiavi sono gli alias, i valori sono i nomi di classe pienamente qualificati. Richiede l'estensione PHP 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

Controlla se $type è un tipo integrato di PHP. In caso contrario è considerato un nome di classe.

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

Usate Nette\Utils\Validators::isBuiltinType().

toString ($reflection): string

Converte un oggetto di reflection in una stringa leggibile.

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