ReflectionType — Klasse · PHP-Referenz

Signatur

class ReflectionType

Beschreibung

ReflectionType ist die abstrakte Basisklasse des PHP-Reflection-API-Typsystems. Sie liefert grundlegende Informationen über einen deklarierten Typ und wird nicht direkt instanziiert, sondern über Methoden wie ReflectionParameter::getType(), ReflectionFunctionAbstract::getReturnType() oder ReflectionProperty::getType() zurückgegeben.

Ab PHP 8.0 gibt es drei konkrete Unterklassen: ReflectionNamedType für einfache Typen wie int oder Foo, ReflectionUnionType für Union-Typen (int|string) und ReflectionIntersectionType für Intersection-Typen (Countable&Iterator). Die Methode allowsNull() ist für alle Varianten verfügbar.

Die Klasse ist besonders nützlich bei der Entwicklung von Frameworks, Dependency-Injection-Containern, Serialisierungsbibliotheken oder Code-Generatoren, die zur Laufzeit auf Typinformationen angewiesen sind.

Da ReflectionType selbst abstrakt ist, sollte man mit instanceof prüfen, welche konkrete Unterklasse vorliegt, bevor man unterklassenspezifische Methoden wie getName() oder getTypes() aufruft.

Beispiele

Parametertypen einer Funktion per Reflection auslesen

<?php
function greet(string $name, ?int $age = null): string {
    return "Hallo $name";
}

$func = new ReflectionFunction('greet');

foreach ($func->getParameters() as $param) {
    $type = $param->getType();
    if ($type === null) {
        echo $param->getName() . ': kein Typ deklariert' . PHP_EOL;
    } else {
        echo $param->getName()
            . ': ' . $type
            . ' (nullable: ' . ($type->allowsNull() ? 'ja' : 'nein') . ')'
            . PHP_EOL;
    }
}

// Rückgabetyp
$returnType = $func->getReturnType();
echo 'Rückgabetyp: ' . $returnType . PHP_EOL;

name: string (nullable: nein) age: ?int (nullable: ja) Rückgabetyp: string

Union-Typ und Named-Typ unterscheiden (PHP 8.0+)

<?php
function process(int|string $value): void {}

$func = new ReflectionFunction('process');
$param = $func->getParameters()[0];
$type = $param->getType();

if ($type instanceof ReflectionUnionType) {
    echo 'Union-Typ mit folgenden Teiltypen:' . PHP_EOL;
    foreach ($type->getTypes() as $t) {
        echo '  - ' . $t->getName() . PHP_EOL;
    }
} elseif ($type instanceof ReflectionNamedType) {
    echo 'Einfacher Typ: ' . $type->getName() . PHP_EOL;
}

Union-Typ mit folgenden Teiltypen: - int - string

Eigenschaftstypen einer Klasse per Reflection inspizieren

<?php
class User {
    public int $id;
    public string $name;
    public ?string $email = null;
}

$ref = new ReflectionClass(User::class);

foreach ($ref->getProperties() as $property) {
    $type = $property->getType();
    if ($type instanceof ReflectionNamedType) {
        echo $property->getName()
            . ': ' . $type->getName()
            . ' (nullable: ' . ($type->allowsNull() ? 'ja' : 'nein') . ')'
            . PHP_EOL;
    }
}

id: int (nullable: nein) name: string (nullable: nein) email: string (nullable: ja)

// Wichtig · Fallstricke

Abstrakte Klasse: ReflectionType kann nicht direkt instanziiert werden. Eigene Unterklassen zu erstellen ist ebenfalls nicht vorgesehen und wird vom Zend-Engine nicht unterstützt.

Stringcast: In PHP 7.x konnte ReflectionType direkt per (string) in den Typnamen umgewandelt werden. Ab PHP 8.0 ist __toString() in ReflectionType als deprecated markiert — für einfache Typen sollte stattdessen ReflectionNamedType::getName() verwendet werden.

Nullable-Typen: Ein Typ wie ?string wird intern als ReflectionNamedType mit allowsNull() === true repräsentiert, nicht als ReflectionUnionType.

PHP-Version: ReflectionUnionType ist erst seit PHP 8.0 verfügbar, ReflectionIntersectionType seit PHP 8.1.

Siehe auch

ReflectionNamedType ReflectionUnionType ReflectionIntersectionType ReflectionParameter ReflectionFunctionAbstract ReflectionProperty ReflectionClass