ReflectionNamedType — Klasse · PHP-Referenz

Signatur

class ReflectionNamedType extends ReflectionType

Beschreibung

ReflectionNamedType ist eine Unterklasse von ReflectionType und wird verwendet, wenn ein Parameter, ein Rückgabewert oder eine Eigenschaft mit einem einzelnen, klar benannten Typ deklariert wurde – etwa int, string, bool, array oder ein Klassenname wie DateTime. Im Gegensatz zu ReflectionUnionType (PHP 8.0+) und ReflectionIntersectionType (PHP 8.1+) steht hier immer genau ein Typ dahinter.

Über die geerbte Methode allowsNull() lässt sich ermitteln, ob der Typ nullable ist (z. B. ?string). Die eigene Methode getName() gibt den Typnamen als String zurück, während isBuiltin() unterscheidet, ob es sich um einen PHP-internen Skalartyp handelt (int, string, bool, float, array, callable, iterable, void, never, null, true, false, mixed) oder um einen benutzerdefinierten Klassen- bzw. Interface-Namen.

Typische Einsatzgebiete sind Dependency-Injection-Container, Code-Generatoren, Serialisierer und andere Systeme, die zur Laufzeit prüfen müssen, welche Typen eine Klasse oder Funktion erwartet oder liefert.

Beispiele

Typ eines Methoden-Parameters auslesen

<?php
class UserService
{
    public function findById(int $id): ?string
    {
        return 'Alice';
    }
}

$ref    = new ReflectionMethod(UserService::class, 'findById');
$params = $ref->getParameters();

foreach ($params as $param) {
    $type = $param->getType();
    if ($type instanceof ReflectionNamedType) {
        echo 'Parameter : $' . $param->getName() . PHP_EOL;
        echo 'Typ       : ' . $type->getName() . PHP_EOL;
        echo 'Builtin?  : ' . ($type->isBuiltin() ? 'ja' : 'nein') . PHP_EOL;
        echo 'Nullable? : ' . ($type->allowsNull() ? 'ja' : 'nein') . PHP_EOL;
    }
}

// Rückgabetyp
$returnType = $ref->getReturnType();
if ($returnType instanceof ReflectionNamedType) {
    echo 'Rückgabe  : ' . $returnType->getName() . PHP_EOL;
    echo 'Nullable? : ' . ($returnType->allowsNull() ? 'ja' : 'nein') . PHP_EOL;
}

Parameter : $id Typ : int Builtin? : ja Nullable? : nein Rückgabe : string Nullable? : ja

Einfacher Dependency-Injection-Container: Klassen-Typ erkennen

<?php
class Logger {}

class OrderService
{
    public function __construct(private Logger $logger) {}
}

function resolveConstructorTypes(string $class): void
{
    $ctor = (new ReflectionClass($class))->getConstructor();
    if ($ctor === null) {
        echo 'Kein Konstruktor.' . PHP_EOL;
        return;
    }

    foreach ($ctor->getParameters() as $param) {
        $type = $param->getType();
        if ($type instanceof ReflectionNamedType && !$type->isBuiltin()) {
            echo sprintf(
                'Parameter $%s erwartet Klasse/Interface: %s%s' . PHP_EOL,
                $param->getName(),
                $type->getName(),
                $type->allowsNull() ? ' (nullable)' : ''
            );
        }
    }
}

resolveConstructorTypes(OrderService::class);

Parameter $logger erwartet Klasse/Interface: Logger

// Wichtig · Fallstricke

PHP-Versionshinweis: ReflectionNamedType wurde mit PHP 7.1 eingeführt. Vor PHP 7.1 lieferte getType() direkt ein ReflectionType-Objekt ohne die Methode getName().

Union- und Intersection-Typen: Ab PHP 8.0 können Typen auch als int|string deklariert werden. In diesem Fall gibt getType() eine Instanz von ReflectionUnionType zurück, nicht von ReflectionNamedType. Ab PHP 8.1 existiert zusätzlich ReflectionIntersectionType. Prüfe daher immer mit instanceof, welche Unterklasse tatsächlich vorliegt, bevor du getName() aufrufst.

Nullable-Typen: Ein als ?Foo deklarierter Typ ist intern ein ReflectionNamedType mit allowsNull() === true – kein Union-Typ, auch wenn er konzeptionell Foo|null entspricht.

Siehe auch

ReflectionType ReflectionUnionType ReflectionIntersectionType ReflectionParameter ReflectionFunctionAbstract ReflectionProperty