Enums in PHP - Deep Dive

Overview - Enums in PHP

What is it?

Enums in PHP are a special type that lets you define a set of named values. They help group related constants under one type, making code easier to read and safer. Instead of using random strings or numbers, enums give meaningful names to fixed options. PHP added enums in version 8.1 to improve code clarity and reduce errors.

Why it matters

Without enums, developers often use plain constants or strings to represent fixed sets of values, which can lead to mistakes like typos or invalid values. Enums solve this by enforcing that only predefined options are used, making programs more reliable and easier to maintain. This reduces bugs and improves communication between developers and the computer.

Where it fits

Before learning enums, you should understand basic PHP syntax, constants, and how to use classes. After enums, you can explore advanced type safety, pattern matching, and design patterns that use enums for clearer logic.

Mental Model

Core Idea

Enums are like labeled boxes that hold a fixed set of allowed values, ensuring you only pick from those boxes in your code.

Think of it like...

Imagine a vending machine with only a few buttons for specific drinks. You can only choose from those drinks, not anything else. Enums are like those buttons, limiting choices to valid options.

┌─────────────┐
│   Enum:     │
│  DrinkType  │
├─────────────┤
│ - Coffee    │
│ - Tea       │
│ - Juice     │
└─────────────┘

Usage:
  DrinkType::Coffee
  DrinkType::Tea
  DrinkType::Juice

Build-Up - 7 Steps

1

Foundation

What is an Enum in PHP

Concept: Introduce the basic idea of enums as a new type in PHP that groups related named values.

Result

Approved!

Understanding that enums create a new type with fixed named values helps prevent invalid inputs and makes code intentions clear.

2

Foundation

Basic Enum Syntax and Usage

Concept: Learn how to declare enums with cases and how to use them in functions and variables.

name; // prints 'North'

Result

North

Knowing the syntax and how to access enum case names is essential for using enums effectively in PHP.

3

Intermediate

Backed Enums with Values

🤔Before reading on: do you think enum cases can hold values like strings or numbers? Commit to your answer.

Concept: Introduce backed enums where each case has a specific string or int value attached.

value; // prints 'approved'

Result

approved

Understanding backed enums allows mapping enum cases to meaningful values, useful for databases or APIs.

4

Intermediate

Using Enums in Switch Statements

🤔Before reading on: do you think switch statements can directly use enum cases? Commit to your answer.

Concept: Show how to use enums in switch statements for clear and safe branching logic.

Result

Right

Using enums in switch statements improves code readability and ensures all cases are handled explicitly.

5

Intermediate

Methods Inside Enums

🤔Before reading on: can enums have functions inside them? Commit to your answer.

Concept: Explain that enums can have methods to add behavior related to their cases.

isFinal()); // bool(false) var_dump(Status::Approved->isFinal()); // bool(true)

Result

bool(false) bool(true)

Knowing enums can have methods lets you bundle related logic with the enum, making code cleaner and more object-oriented.

6

Advanced

Enum Implementing Interfaces

🤔Before reading on: do you think enums can implement interfaces like classes? Commit to your answer.

Concept: Show that enums can implement interfaces to guarantee certain methods exist.

'Upwards', self::South => 'Downwards', self::East => 'Right', self::West => 'Left', }; } } echo Direction::West->describe();

Result

Left

Understanding that enums can implement interfaces allows for flexible and consistent design patterns.

7

Expert

Enum Internals and Performance

🤔Before reading on: do you think enums are just syntactic sugar or have real runtime differences? Commit to your answer.

Concept: Explore how PHP stores enums internally and their impact on performance and type safety.

Enums in PHP are implemented as special classes with final cases. Each case is a singleton object, ensuring identity and memory efficiency. Backed enums store their values as properties. This design allows fast comparisons and strict type checks at runtime.

Result

Enums provide both type safety and efficient memory use compared to plain constants.

Knowing the internal design of enums helps understand their benefits and limitations in large applications.

Under the Hood

PHP enums are compiled into final classes with private constructors. Each enum case is a unique singleton instance of that class. Backed enums add a private property holding the backing value (string or int). When you use an enum case, PHP returns the same instance every time, enabling identity checks with ===. The enum class also provides static methods to get all cases or find a case by its backing value.

Why designed this way?

Enums were designed to provide a type-safe alternative to constants and strings, reducing bugs from invalid values. Using singleton instances for cases ensures memory efficiency and fast identity checks. Backed enums allow easy integration with external data like databases. This design balances usability, performance, and strict typing.

┌─────────────────────────────┐
│        Enum Class           │
│  +-----------------------+  │
│  |  private constructor   |  │
│  |  static cases as objs  |  │
│  |  methods (cases(), from())│
│  +-----------------------+  │
└─────────────┬───────────────┘
              │
      ┌───────┴────────┐
      │                │
┌─────────────┐  ┌─────────────┐
│ Enum Case 1 │  │ Enum Case 2 │
│ (singleton) │  │ (singleton) │
└─────────────┘  └─────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think enum cases can be changed after definition? Commit to yes or no.

Common Belief: Enum cases are like variables and can be reassigned or changed at runtime.

Reality: Enum cases are fixed and immutable singletons; you cannot add, remove, or change cases after definition.

Why it matters: Trying to modify enum cases leads to errors or unexpected behavior, breaking the guarantees enums provide.

Quick: Can you use any value type as a backing value in enums? Commit to yes or no.

Common Belief: Enums can have any type of backing value, like arrays or objects.

Reality: Backed enums only support string or int as backing value types.

Why it matters: Using unsupported types causes syntax errors and limits how enums can represent data.

Quick: Do you think enums are just constants with fancy names? Commit to yes or no.

Common Belief: Enums are just a nicer way to write constants with no real difference.

Reality: Enums are full types with identity, methods, and type safety, unlike plain constants.

Why it matters: Treating enums as constants misses their power and can lead to less safe and less maintainable code.

Quick: Can you compare backed enum cases by their backing values only? Commit to yes or no.

Common Belief: Comparing backed enum cases by their backing values is the same as comparing the cases themselves.

Reality: Enum cases must be compared by identity (===), not just backing value, to avoid errors.

Why it matters: Incorrect comparisons can cause bugs when different cases share the same backing value or when identity matters.

Expert Zone

1

Enums can be used as keys in arrays or maps because their cases are objects with stable identity.

2

Backed enums allow seamless integration with databases by mapping stored values to enum cases automatically.

3

Using methods inside enums encourages encapsulation of related logic, reducing scattered conditional code.

When NOT to use

Avoid enums when the set of values is dynamic or unknown at compile time; use classes or configuration instead. Also, for very simple flags, bitmasks or constants might be more efficient.

Production Patterns

In production, enums are often used for status codes, user roles, configuration options, and API response types. They improve validation, reduce magic strings, and enable IDE autocompletion and static analysis.

Connections

Algebraic Data Types (ADTs)

Enums in PHP are a form of tagged union or sum type, similar to ADTs in functional programming.

Understanding enums as ADTs helps grasp how they represent fixed sets of alternatives with possible data, bridging PHP with functional programming concepts.

State Machines

Enums often represent states in state machines, defining allowed states and transitions.

Knowing enums helps design clear and safe state machines by restricting states to valid options.

Traffic Light System (Real-world System)

Enums model fixed categories like traffic light colors, which have limited valid states.

Seeing enums as modeling real-world fixed categories clarifies their purpose in programming.

Common Pitfalls

#1 Using strings instead of enum cases causes bugs and typos.

Wrong approach:

function setStatus(string $status) {
if ($status === 'approved') {
echo 'Approved';
}
}
setStatus('aproved'); // typo here, no error

Correct approach:

function setStatus(Status $status) {
if ($status === Status::Approved) {
echo 'Approved';
}
}
setStatus(Status::Approved); // safe and typo-proof

Root cause:

Not using enums loses type safety and allows invalid values silently.

#2 Trying to add new enum cases at runtime.

Wrong approach:

enum Color {
case Red;
}
// Later in code
Color::Green = new Color(); // invalid

Correct approach:

enum Color {
case Red;
case Green;
}

Root cause:

Enums are fixed at compile time; runtime modification is not allowed.

#3 Comparing enum cases with == instead of === can cause subtle bugs.

Wrong approach:

if ($status == Status::Approved) { ... } // loose comparison

Correct approach:

if ($status === Status::Approved) { ... } // strict identity check

Root cause:

Loose comparison may not check identity, leading to false positives.

Key Takeaways

Enums in PHP provide a clear, type-safe way to represent fixed sets of related values.

Backed enums link enum cases to specific string or integer values, useful for external data.

Enums can have methods and implement interfaces, making them powerful and flexible types.

Using enums prevents bugs from invalid values and improves code readability and maintainability.

Understanding enum internals reveals why they are efficient and reliable compared to constants.