Update for PHP8.3:

$name = 'REVIEWED';
Status::{$name}->value;
Status::{'REVIEWED')->value;

https://php.watch/versions/8.3/dynamic-class-const-enum-member-syntax-support

Previously:

You can use reflection for Backed case:

$reflection = new ReflectionEnumBackedCase(Status::class, 'REVIEWED');
$reflection->getBackingValue(); // 2
$reflection->getValue() // Status::REVIEWED if you need case object

Or enum reflection:

$reflection = new ReflectionEnum(Status::class);
$reflection->getCase('REVIEWED')->getValue()->value // 2

see also ReflectionEnumUnitCase

The constant() function can return the value of a constant using a string variable.

This also applies to Enum class constants as mentioned in the basic enumeration section of the PHP Manual.

$name = 'REVIEWED';
$status = constant("Status::{$name}");

You can also use the constant() function to get the Enum, then get the value from that. And personally, I would use a trait so you don't have to create the function for every enum you want this feature for:

trait EnumFromName
{
    public static function valueFromName(string $name): self
    {
        return constant("self::$name");
    }
}

Enum class:

enum Status : int
{
    use EnumFromName;

    case ACTIVE = 1;
    case REVIEWED = 2;
    // ...
}

Calling:

Status::valueFromName('REVIEWED')->value;

You need to use tryFrom or from:

Example of enum:

enum Fruits: string
{
    case APPLE = 'Apple';
    case PEAR = 'Pear';
    case ORANGE = 'Orange';

    public function getDescription(): string
    {
        return match ($this) {
            Fruits::APPLE => 'X',
            Fruits::PEAR => 'Y',
            Fruits::ORANGE => 'Z',
        };
    }

}

tryFrom: Get Enum instance or null from string

Maps a scalar to an enum instance or null

$stringValue = 'Pear';

$fruit = Fruits::tryFrom($stringValue);

if ($fruit !== null) {
   echo $fruit->getDescription(); // "Y"
   echo $fruit->value; // "Pear"
}

Documentation: https://www.php.net/manual/en/backedenum.tryfrom.php

from: Get Enum instance or ValueError from string

Maps a scalar to an enum instance or throw a ValueError exception

$stringValue = 'Pear';

try { 
   $fruit = Fruits::from($stringValue);

   echo $fruit->getDescription(); // "Y"
   echo $fruit->value; // "Pear"
} catch (\ValueError $exception) { 
   echo $exception->getMessage(); // Fatal error: Uncaught ValueError: "Tree" is not a valid backing value for enum "Fruit"
}

Documentation: https://www.php.net/manual/en/backedenum.from.php

I use a custom method too, but I return an enum. The from method returns an enum, not a value. I think the fromName method should return an enum too. Then you have access to all methods of the enum. You don't need use another method - from.

public static function fromName(string $name): self
{
    foreach (self::cases() as $status) {
        if( $name === $status->name ){
            return $status;
        }
    }
    throw new \ValueError("$name is not a valid backing value for enum " . self::class );
}

public static function tryFromName(string $name): self|null
{
    try {
        return self::fromName($name);
    } catch (\ValueError $error) {
        return null;
    }
}

If anyone cares, I have created a library around that.

https://github.com/henzeb/enumhancer

Just add the trait to your enum

enum Status : int
{
    use Henzeb\Enumhancer\Enhancers;
    
    case ACTIVE = 1;
    case REVIEWED = 2;
    // ...
}

Status::get('ACTIVE');
Status::tryGet('ACTIVE');

You then don't have to use values at all. In that case you can also simply use from.

enum Status
{
    use Henzeb\Enumhancer\Enhancers;
    
    case ACTIVE;
    case REVIEWED;
    // ...
}

Status::from('ACTIVE')->key(); // returns 0
Status::tryFrom('Reviewed')->key(); // returns 1

It does so much more than that, but it defeats copying and pasting snippets around.

To get value from the name:

enum Status : int
{
   case ACTIVE = 1;
   case REVIEWED = 2;
   // ...
}

print(Status::REVIEWED->value);

Enum documentation

This is what I did - https://3v4l.org/8R2fP#v8.2.10:

<?php

enum Gender
{
    case UNKNOWN;
    case MALE;
    case FEMALE;
}

/**
 * @template T as BackedEnum|UnitEnum
 * @param class-string<T> $enumClass
 * @param string $name
 * @return T|null
 */
function tryFromName(string $enumClass, string $name)
{
    $constName = $enumClass . '::' . $name;

    return is_subclass_of($enumClass, UnitEnum::class) && defined($constName)
        ? constant($constName)
        : null;
}

// enum(Gender::UNKNOWN)
var_dump(tryFromName(Gender::class, 'UNKNOWN'));

// enum(Gender::MALE)
var_dump(tryFromName(Gender::class, 'MALE'));

// enum(Gender::FEMALE)
var_dump(tryFromName(Gender::class, 'FEMALE'));

// NULL
var_dump(tryFromName(Gender::class, 'null'));

Update at 31/05/2025

This can be achived with Backed enumerations ¶:

<?php

enum Suit: string
{
    case Hearts = 'H';
    case Diamonds = 'D';
    case Clubs = 'C';
    case Spades = 'S';
}

Then you can do:

$record = 'C';
$suit =  Suit::from($record);
// Invalid data throws a ValueError: "X" is not a valid scalar value for enum "Suit"
print $suit->value;