Create Enum from Name in PHP

Question

In PHP 8.1, BackedEnum offer a from and tryFrom method to get an enum from a value. How can the same be achieved by non backed enums?

Example BackedEnum:

enum MainType: string
{
    case Full = 'a';
    case Major = 'b';
    case Minor = 'c';
}

var_dump(MainType::tryFrom('a')); // MainType::Full
var_dump(MainType::tryFrom('d')); // null

However this doesn't exist for regular enums.

How would I retrieve a "normal" Enum by name, like:

enum MainType
{
    case Full;
    case Major;
    case Minor;
}

$name = (MainType::Full)->name
var_dump(name); // (string) Full

One option I've found is to simply add a tryFromName function, accepting a string and looping over all the cases like this:

enum MainType
{
    case Full;
    case Major;
    case Minor;

    public static function tryFromName(string $name): ?static
    {
        foreach (static::cases() as $case) {
            if ($case->name === $name) {
                return $case;
            }
        }

        return null;
    }
}

$name = (MainType::Full)->name
var_dump(name); // (string) Full
var_dump(MainType::tryFromName($name)); // MainType::Full

This works, however it seams counter intuitive to enable a foreach loop going over all possibilities just to create an enum.

Therefore the question is, what is the right way to get an Enum in PHP from the name.

Answer 1

You can use Reflection:

trait Enum {

    public static function tryFromName(string $name): ?static
    {
        $reflection = new ReflectionEnum(static::class);

        if (!$reflection->hasCase($name)) {
            return null;
        }

        /** @var static */
        return $reflection->getCase($name)->getValue();
    }

}

enum Foo {
    use Enum;

    case ONE;
    case TWO;
}

var_dump( Foo::tryFromName('TWO')   ); // enum(Foo::TWO)
var_dump( Foo::tryFromName('THREE') ); // null

Works also for Backed Enums.

Answer 2

I love the use of ReflectionEnum in @hejdav's answer and it works PHP8.1+, and this would be my preference.

Unfortunately that time it failed with Phpstan tests saying Method EnumClass::tryFromName() should return EnumClass|null but returns UnitEnum|null., so I resorted to using the following:

trait EnumFromName
{
    /**
     * To mirror backed enums tryFrom - returns null on failed match.
     */
    public static function tryFromName(string $name): ?static
    {
        return array_column(static::cases(), null, 'name')[$name] ?? null;
    }

    /**
     * To mirror backed enums from - throws ValueError on failed match.
     */
    public static function fromName(string $name): static
    {
        return self::tryFromName($name)
            ?? throw new ValueError(sprintf(
                   '%s is not a valid case for enum %s',
                   $name, 
                   static::class
               ));

    }
}

Answer 3

I can't comment on Duncanmoo's response since I have no reputation yet.

But in PHP 8.4, you can simplify it to

public static function tryFromName(string $name): ?static
{
  return array_find(self::cases(), fn($case) => $case->name === $name);
}

Answer 4

One more PHP 8.1 solution like @Duncanmoo answer, but with speed optimization using static varibale to store indexed cases list

trait EnumFromName {

    public static function tryFromName(string $name): ?static 
    {
        /** @var ?array<non-empty-string, static> */
        static $cache;

        $cache ??= array_column(static::cases(), null, 'name');

        return $cache[$name] ?? null;
    }

    public static function fromName(string $name): static 
    {
        /** @var static */
        return static::tryFromName($name);
    }
}

With optimization: Execution time: 0.401827s

Without optimization: Execution time: 1.832551s

Difference will grow with large number of cases.