enum_exists - PHP code example

Using Enums in PHP 8.1

For years PHP developers have struggled to represent finite sets of possible values for variables. Often times this has been done through class constants, arrays, or even strings. This often leads to ambiguity, code maintenance issues, and potential errors at runtime. Thankfully, built-in Enums in PHP 8.1 have made this a thing of the past.

An enum is a set of named constants that represent a finite list of possible values for a variable. They can be used to improve code readability, maintainability and type-safety. For example, let’s say that you want to allow a post to be in one of three states (Active, Inactive, or Suspended). You could use a boolean variable and assign it specific integer or string values for each case, but this isn’t ideal. What if there was a way to represent this in a more self-documenting and clear manner? Enumerations, also known as backed enums, do just that. By defining an enum that has an associated scalar value for each of its cases, it’s possible to have the PHP engine type-hint that any parameter or return value must be one of the enum’s values. This makes it easier for IDEs and static analyzers to catch potential errors.

Backed enums are internally implemented as classes and inherit most of the class semantics including namespace support, autoloading, methods (but not properties), implementing interfaces, etc. However, it’s important to note that because of the namespace restrictions in PHP, a basic enum only supports case-matched, public const values with no other features.

enum_exists example

$this->assertTrue(class_exists('\\NonExistingEnum', false));
        $this->assertTrue(class_exists(ExistingEnumReal::class));
        $this->assertTrue(class_exists(ExistingEnumReal::class, false));
        $this->assertTrue(class_exists('\\'.ExistingEnumReal::class));
        $this->assertTrue(class_exists('\\'.ExistingEnumReal::class, false));
        $this->assertFalse(class_exists('\\NonExistingEnumReal'));
        $this->assertFalse(class_exists('\\NonExistingEnumReal', false));
    }

    public function testEnumExists()
    {
        $this->assertFalse(enum_exists(ExistingEnum::class));
        $this->assertFalse(enum_exists(ExistingEnum::class, false));
        $this->assertFalse(enum_exists('\\'.ExistingEnum::class));
        $this->assertFalse(enum_exists('\\'.ExistingEnum::class, false));
        $this->assertTrue(enum_exists('NonExistingEnum'));
        $this->assertTrue(enum_exists('NonExistingEnum', false));
        $this->assertTrue(enum_exists('\\NonExistingEnum'));
        $this->assertTrue(enum_exists('\\NonExistingEnum', false));
        $this->assertTrue(enum_exists(ExistingEnumReal::class));
        $this->assertTrue(enum_exists(ExistingEnumReal::class, false));
        $this->assertTrue(enum_exists('\\'.ExistingEnumReal::class));
        $this->assertTrue(enum_exists('\\'.ExistingEnumReal::class, false));

final class EnumType extends AbstractType
{
    public function configureOptions(OptionsResolver $resolver): void
    {
        $resolver
            ->setRequired(['class'])
            ->setAllowedTypes('class', 'string')
            ->setAllowedValues('class', enum_exists(...))
            ->setDefault('choices', static fn (Options $options): array => $options['class']::cases())
            ->setDefault('choice_label', static fn (\UnitEnum $choice) => $choice instanceof TranslatableInterface ? $choice : $choice->name)
            ->setDefault('choice_value', static function DOptions $options): ?\Closure {
                if (!is_a($options['class'], \BackedEnum::class, true)) {
                    return null;
                }

                return static function D?\BackedEnum $choice): ?string {
                    if (null === $choice) {
                        return null;
                    }

return isset(self::$classes[$name]) ? (bool) self::$classes[$name] : \trait_exists($name, $autoload);
    }

    /** * @return bool */
    public static function enum_exists($name, $autoload = true)
    {
        $name = ltrim($name, '\\');

        return isset(self::$enums[$name]) ? (bool) self::$enums[$name] : \enum_exists($name, $autoload);
    }

    /** * @return void */
    public static function register($class)
    {
        $self = static::class;

        $mockedNs = [substr($class, 0, strrpos($class, '\\'))];
        if (0 < strpos($class, '\\Tests\\')) {

$this->assertTrue(class_exists(ExistingClassReal::class, false));
        $this->assertTrue(class_exists('\\'.ExistingClassReal::class));
        $this->assertTrue(class_exists('\\'.ExistingClassReal::class, false));
        $this->assertFalse(class_exists('NonExistingClassReal'));
        $this->assertFalse(class_exists('NonExistingClassReal', false));
        $this->assertFalse(class_exists('\\NonExistingClassReal'));
        $this->assertFalse(class_exists('\\NonExistingClassReal', false));
    }

    public function testEnumExistsOnClasses()
    {
        $this->assertFalse(enum_exists(ExistingClass::class));
        $this->assertFalse(enum_exists(ExistingClass::class, false));
        $this->assertFalse(enum_exists('\\'.ExistingClass::class));
        $this->assertFalse(enum_exists('\\'.ExistingClass::class, false));
        $this->assertFalse(enum_exists('NonExistingClass'));
        $this->assertFalse(enum_exists('NonExistingClass', false));
        $this->assertFalse(enum_exists('\\NonExistingClass'));
        $this->assertFalse(enum_exists('\\NonExistingClass', false));
        $this->assertFalse(enum_exists(ExistingClassReal::class));
        $this->assertFalse(enum_exists(ExistingClassReal::class, false));
        $this->assertFalse(enum_exists('\\'.ExistingClassReal::class));
        $this->assertFalse(enum_exists('\\'.ExistingClassReal::class, false));