ReflectionEnumBackedCase — Enum · PHP-Referenz

Signatur

class ReflectionEnumBackedCase extends ReflectionEnumUnitCase implements ReflectionClassConstant

Beschreibung

ReflectionEnumBackedCase ist eine Klasse der PHP-Reflection-API und erweitert ReflectionEnumUnitCase um den Zugriff auf den skalaren Wert (backing value) eines Enum-Cases. Sie wird verwendet, wenn ein Enum ein skalares Äquivalent besitzt, also als string- oder int-backed Enum deklariert wurde.

Instanzen dieser Klasse werden typischerweise nicht direkt erzeugt, sondern über die Methode ReflectionEnum::getCase() oder ReflectionEnum::getCases() bezogen. Stellt der zurückgegebene Case einen backed Enum-Case dar, ist die Instanz vom Typ ReflectionEnumBackedCase.

Die wichtigste Erweiterung gegenüber der Basisklasse ist die Methode getBackingValue(), die den skalaren Wert des Cases zurückgibt – also den Wert, der bei der Enum-Deklaration nach dem Gleichheitszeichen steht (z. B. Status::Active = 'active').

Diese Klasse ist besonders nützlich, wenn Enum-Cases zur Laufzeit dynamisch analysiert, serialisiert oder in Formularen und APIs verarbeitet werden müssen.

Beispiele

Backing-Wert eines String-backed Enums auslesen

<?php
enum Status: string
{
    case Active   = 'active';
    case Inactive = 'inactive';
    case Pending  = 'pending';
}

$reflector = new ReflectionEnum(Status::class);

foreach ($reflector->getCases() as $case) {
    if ($case instanceof ReflectionEnumBackedCase) {
        echo $case->getName() . ' => ' . $case->getBackingValue() . PHP_EOL;
    }
}

Active => active Inactive => inactive Pending => pending

Einzelnen Case per Name reflektieren und Backing-Wert prüfen

<?php
enum Priority: int
{
    case Low    = 1;
    case Medium = 5;
    case High   = 10;
}

$reflector = new ReflectionEnum(Priority::class);
$case      = $reflector->getCase('High');

if ($case instanceof ReflectionEnumBackedCase) {
    echo 'Name:          ' . $case->getName()         . PHP_EOL;
    echo 'Backing-Wert:  ' . $case->getBackingValue() . PHP_EOL;
    // Zugriff auf das echte Enum-Objekt:
    $enumValue = $case->getValue();
    echo 'Enum-Objekt:   ' . $enumValue->name         . PHP_EOL;
}

Name: High Backing-Wert: 10 Enum-Objekt: High

Backed vs. Unit-Cases unterscheiden

<?php
enum Direction
{
    case North;
    case South;
}

enum Color: string
{
    case Red   = 'red';
    case Green = 'green';
}

foreach ([Direction::class, Color::class] as $enumClass) {
    $ref = new ReflectionEnum($enumClass);
    foreach ($ref->getCases() as $case) {
        $type = $case instanceof ReflectionEnumBackedCase ? 'Backed' : 'Unit';
        echo "[{$type}] {$enumClass}::{$case->getName()}" . PHP_EOL;
    }
}

[Unit] Direction::North [Unit] Direction::South [Backed] Color::Red [Backed] Color::Green

// Wichtig · Fallstricke

Nur für backed Enums: Versucht man, getBackingValue() auf einem ReflectionEnumUnitCase aufzurufen (also einem Enum ohne skalaren Typ), führt das zu einem Fehler. Prüfe daher immer mit instanceof ReflectionEnumBackedCase, bevor du diese Methode verwendest.

Nicht direkt instanziieren: ReflectionEnumBackedCase-Objekte sollten ausschließlich über die Reflection-API bezogen werden (ReflectionEnum::getCase(), ReflectionEnum::getCases()), da der Konstruktor intern den Kontext des Enums benötigt.

Vererbungshierarchie: ReflectionEnumBackedCase → ReflectionEnumUnitCase → ReflectionClassConstant. Alle Methoden der Elternklassen stehen damit ebenfalls zur Verfügung, z. B. getDocComment(), getAttributes() oder isPublic().

Siehe auch

ReflectionEnum ReflectionEnumUnitCase ReflectionClassConstant ReflectionEnumBackedCase::getBackingValue ReflectionEnum::getCase ReflectionEnum::getCases