Enums

Enums (enumerations) are a way to define a set of named constants. They provide type safety and make code more readable by using meaningful names instead of magic numbers or strings.

What are Enums?

An enum is a special type that represents a fixed set of constants. Instead of using arbitrary numbers or strings, enums allow you to use meaningful names.

Why Use Enums?

• Type Safety - Prevents invalid values
• Readability - Code is self-documenting
• Maintainability - Easy to update values in one place
• IDE Support - Better autocomplete and refactoring

Basic Enums

Different languages implement enums in different ways:

💡 Tip: Click dropdown to switch between languages

Python

Python

basic_enum.py

from enum import Enum

class Status(Enum):
    """Simple enum for status values"""
    PENDING = "pending"
    ACTIVE = "active"
    INACTIVE = "inactive"
    DELETED = "deleted"

# Usage
user_status = Status.ACTIVE
print(user_status)           # Status.ACTIVE
print(user_status.value)     # "active"
print(user_status.name)      # "ACTIVE"

# Compare enum values
if user_status == Status.ACTIVE:
    print("User is active")

Output

Status.ACTIVE
active
ACTIVE
User is active

Java

BasicEnum.java

public enum Status {
    PENDING("pending"),
    ACTIVE("active"),
    INACTIVE("inactive"),
    DELETED("deleted");

    private final String value;

    Status(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Status userStatus = Status.ACTIVE;
        System.out.println(userStatus);              // ACTIVE
        System.out.println(userStatus.getValue());   // "active"
        System.out.println(userStatus.name());       // "ACTIVE"

        // Compare enum values
        if (userStatus == Status.ACTIVE) {
            System.out.println("User is active");
        }
    }
}

Output

ACTIVE
active
ACTIVE
User is active

TypeScript

basic-enum.ts

enum Status {
    PENDING = "pending",
    ACTIVE = "active",
    INACTIVE = "inactive",
    DELETED = "deleted"
}

// Usage
const userStatus: Status = Status.ACTIVE;
console.log(userStatus);           // "active"
console.log(Status[userStatus]);   // undefined (reverse mapping doesn't work with string enums)
console.log(Status.ACTIVE);        // "active"

// Compare enum values
if (userStatus === Status.ACTIVE) {
    console.log("User is active");
}

Output

active
undefined
active
User is active

C++

basic_enum.cpp

#include <iostream>
#include <string>
#include <map>

enum class Status {
    PENDING,
    ACTIVE,
    INACTIVE,
    DELETED
};

// Helper to convert enum to string
std::string statusToString(Status status) {
    static const std::map<Status, std::string> statusMap = {
        {Status::PENDING, "pending"},
        {Status::ACTIVE, "active"},
        {Status::INACTIVE, "inactive"},
        {Status::DELETED, "deleted"}
    };
    return statusMap.at(status);
}

int main() {
    Status userStatus = Status::ACTIVE;
    std::cout << "Status: ACTIVE" << std::endl;
    std::cout << statusToString(userStatus) << std::endl;  // "active"
    std::cout << "ACTIVE" << std::endl;

    // Compare enum values
    if (userStatus == Status::ACTIVE) {
        std::cout << "User is active" << std::endl;
    }

    return 0;
}

Output

Status: ACTIVE
active
ACTIVE
User is active

C#

BasicEnum.cs

using System;

public enum Status {
    PENDING,
    ACTIVE,
    INACTIVE,
    DELETED
}

// Extension method for string values
public static class StatusExtensions {
    public static string GetValue(this Status status) {
        return status switch {
            Status.PENDING => "pending",
            Status.ACTIVE => "active",
            Status.INACTIVE => "inactive",
            Status.DELETED => "deleted",
            _ => throw new ArgumentException("Invalid status")
        };
    }
}

public class Program {
    public static void Main() {
        Status userStatus = Status.ACTIVE;
        Console.WriteLine(userStatus);              // ACTIVE
        Console.WriteLine(userStatus.GetValue());   // "active"
        Console.WriteLine(userStatus.ToString());   // "ACTIVE"

        // Compare enum values
        if (userStatus == Status.ACTIVE) {
            Console.WriteLine("User is active");
        }
    }
}

Output

ACTIVE
active
ACTIVE
User is active

Go

basic_enum.go

package main

import "fmt"

type Status int

const (
  PENDING Status = iota
  ACTIVE
  INACTIVE
  DELETED
)

func (s Status) Value() string {
  vals := []string{"pending", "active", "inactive", "deleted"}
  return vals[s]
}

func (s Status) EnumName() string {
  names := []string{"PENDING", "ACTIVE", "INACTIVE", "DELETED"}
  return names[s]
}

func main() {
  userStatus := ACTIVE
  fmt.Println(userStatus.EnumName())
  fmt.Println(userStatus.Value())
  fmt.Println(userStatus.EnumName())
  if userStatus == ACTIVE {
    fmt.Println("User is active")
  }
}

Output

ACTIVE
active
ACTIVE
User is active

Rust

basic_enum.rs

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Status {
    Pending,
    Active,
    Inactive,
    Deleted,
}

impl Status {
    fn value(self) -> &'static str {
        match self {
            Status::Pending => "pending",
            Status::Active => "active",
            Status::Inactive => "inactive",
            Status::Deleted => "deleted",
        }
    }

    fn enum_name(self) -> &'static str {
        match self {
            Status::Pending => "PENDING",
            Status::Active => "ACTIVE",
            Status::Inactive => "INACTIVE",
            Status::Deleted => "DELETED",
        }
    }
}

fn main() {
    let user_status = Status::Active;
    println!("{}", user_status.enum_name());
    println!("{}", user_status.value());
    println!("{}", user_status.enum_name());
    if user_status == Status::Active {
        println!("User is active");
    }
}

Output

ACTIVE
active
ACTIVE
User is active

Enum with Integer Values

Enums can use integer values:

💡 Tip: Click dropdown to switch between languages

Python

Python

int_enum.py

from enum import IntEnum

class Priority(IntEnum):
    """Enum with integer values"""
    LOW = 1
    MEDIUM = 2
    HIGH = 3
    CRITICAL = 4

# Can compare with integers
priority = Priority.HIGH
print(priority)           # Priority.HIGH
print(priority.value)     # 3
print(priority < Priority.CRITICAL)  # True
print(priority == 3)      # True (IntEnum allows this)

Output

Priority.HIGH
3
True
True

Java

IntEnum.java

public enum Priority {
    LOW(1),
    MEDIUM(2),
    HIGH(3),
    CRITICAL(4);

    private final int value;

    Priority(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    // Compare with integers
    public boolean isHigherThan(Priority other) {
        return this.value > other.value;
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Priority priority = Priority.HIGH;
        System.out.println(priority);                    // HIGH
        System.out.println(priority.getValue());        // 3
        System.out.println(priority.isHigherThan(Priority.MEDIUM));  // True
    }
}

Output

HIGH
3
True

TypeScript

int-enum.ts

enum Priority {
    LOW = 1,
    MEDIUM = 2,
    HIGH = 3,
    CRITICAL = 4
}

// Can compare with numbers
const priority: Priority = Priority.HIGH;
console.log(priority);                    // 3
console.log(priority);                    // 3
console.log(priority < Priority.CRITICAL); // true
console.log(priority === 3);               // true (numeric enums allow this)

Output

3
3
true
true

C++

int_enum.cpp

#include <iostream>

enum class Priority {
    LOW = 1,
    MEDIUM = 2,
    HIGH = 3,
    CRITICAL = 4
};

int main() {
    Priority priority = Priority::HIGH;
    std::cout << "Priority::HIGH" << std::endl;
    std::cout << static_cast<int>(priority) << std::endl;  // 3
    std::cout << (priority < Priority::CRITICAL) << std::endl;  // 1 (true)
    std::cout << (static_cast<int>(priority) == 3) << std::endl;  // 1 (true)

    return 0;
}

Output

Priority::HIGH
3
1
1

C#

IntEnum.cs

using System;

public enum Priority {
    LOW = 1,
    MEDIUM = 2,
    HIGH = 3,
    CRITICAL = 4
}

public class Program {
    public static void Main() {
        Priority priority = Priority.HIGH;
        Console.WriteLine(priority);              // HIGH
        Console.WriteLine((int)priority);         // 3
        Console.WriteLine(priority < Priority.CRITICAL);  // True
        Console.WriteLine((int)priority == 3);    // True
    }
}

Output

HIGH
3
True
True

Go

int_enum.go

package main

import "fmt"

type Priority int

const (
  LOW Priority = iota + 1
  MEDIUM
  HIGH
  CRITICAL
)

func (p Priority) String() string {
  names := []string{"LOW", "MEDIUM", "HIGH", "CRITICAL"}
  return names[p-1]
}

func main() {
  priority := HIGH
  fmt.Println(priority)
  fmt.Println(int(priority))
  fmt.Println(priority < CRITICAL)
  fmt.Println(int(priority) == 3)
}

Output

HIGH
3
true
true

Rust

int_enum.rs

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
enum Priority {
    Low = 1,
    Medium,
    High,
    Critical,
}

impl Priority {
    fn name(self) -> &'static str {
        match self {
            Priority::Low => "LOW",
            Priority::Medium => "MEDIUM",
            Priority::High => "HIGH",
            Priority::Critical => "CRITICAL",
        }
    }
}

fn main() {
    let priority = Priority::High;
    println!("{}", priority.name());
    println!("{}", priority as i32);
    println!("{}", priority < Priority::Critical);
    println!("{}", priority as i32 == 3);
}

Output

HIGH
3
true
true

Enum with Methods

Enums can have methods and properties:

💡 Tip: Click dropdown to switch between languages

Python

Python

enum_with_methods.py

from enum import Enum

class Color(Enum):
    """Enum with methods"""
    RED = (255, 0, 0)
    GREEN = (0, 255, 0)
    BLUE = (0, 0, 255)
    YELLOW = (255, 255, 0)

    def __init__(self, r, g, b):
        self.r = r
        self.g = g
        self.b = b

    def rgb(self):
        """Return RGB tuple"""
        return (self.r, self.g, self.b)

    def hex(self):
        """Return hex color code"""
        return f"#{self.r:02x}{self.g:02x}{self.b:02x}"

    def is_dark(self):
        """Check if color is dark"""
        return (self.r + self.g + self.b) < 400

# Usage
color = Color.RED
print(color.rgb())      # (255, 0, 0)
print(color.hex())      # #ff0000
print(color.is_dark())  # False

Output

(255, 0, 0)
#ff0000
False

Java

EnumWithMethods.java

public enum Color {
    RED(255, 0, 0),
    GREEN(0, 255, 0),
    BLUE(0, 0, 255),
    YELLOW(255, 255, 0);

    private final int r;
    private final int g;
    private final int b;

    Color(int r, int g, int b) {
        this.r = r;
        this.g = g;
        this.b = b;
    }

    // Return RGB array
    public int[] rgb() {
        return new int[]{r, g, b};
    }

    // Return hex color code
    public String hex() {
        return String.format("#%02x%02x%02x", r, g, b);
    }

    // Check if color is dark
    public boolean isDark() {
        return (r + g + b) < 400;
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Color color = Color.RED;
        System.out.println(java.util.Arrays.toString(color.rgb()));  // [255, 0, 0]
        System.out.println(color.hex());      // #ff0000
        System.out.println(color.isDark());   // false
    }
}

Output

[255, 0, 0]
#ff0000
false

TypeScript

enum-with-methods.ts

class Color {
    static readonly RED = new Color(255, 0, 0);
    static readonly GREEN = new Color(0, 255, 0);
    static readonly BLUE = new Color(0, 0, 255);
    static readonly YELLOW = new Color(255, 255, 0);

    constructor(
        public readonly r: number,
        public readonly g: number,
        public readonly b: number
    ) {}

    rgb(): [number, number, number] {
        return [this.r, this.g, this.b];
    }

    hex(): string {
        return `#${this.r.toString(16).padStart(2, '0')}${this.g.toString(16).padStart(2, '0')}${this.b.toString(16).padStart(2, '0')}`;
    }

    isDark(): boolean {
        return (this.r + this.g + this.b) < 400;
    }
}

// Usage
const color = Color.RED;
console.log(color.rgb());      // [255, 0, 0]
console.log(color.hex());      // #ff0000
console.log(color.isDark());   // false

Output

[ 255, 0, 0 ]
#ff0000
false

C++

enum_with_methods.cpp

#include <iostream>
#include <string>
#include <sstream>
#include <iomanip>

class Color {
public:
    enum Value {
        RED,
        GREEN,
        BLUE,
        YELLOW
    };

private:
    int r, g, b;
    Value value;

public:
    Color(Value val, int r, int g, int b) : value(val), r(r), g(g), b(b) {}

    static Color Red() { return Color(RED, 255, 0, 0); }
    static Color Green() { return Color(GREEN, 0, 255, 0); }
    static Color Blue() { return Color(BLUE, 0, 0, 255); }
    static Color Yellow() { return Color(YELLOW, 255, 255, 0); }

    std::string rgb() const {
        return "(" + std::to_string(r) + ", " + std::to_string(g) + ", " + std::to_string(b) + ")";
    }

    std::string hex() const {
        std::stringstream ss;
        ss << "#" << std::hex << std::setfill('0')
           << std::setw(2) << r
           << std::setw(2) << g
           << std::setw(2) << b;
        return ss.str();
    }

    bool isDark() const {
        return (r + g + b) < 400;
    }
};

int main() {
    Color color = Color::Red();
    std::cout << color.rgb() << std::endl;       // (255, 0, 0)
    std::cout << color.hex() << std::endl;       // #ff0000
    std::cout << (color.isDark() ? "true" : "false") << std::endl;  // false

    return 0;
}

Output

(255, 0, 0)
#ff0000
false

C#

EnumWithMethods.cs

using System;

public enum ColorValue {
    RED,
    GREEN,
    BLUE,
    YELLOW
}

public class Color {
    public ColorValue Value { get; }
    public int R { get; }
    public int G { get; }
    public int B { get; }

    public static Color RED = new Color(ColorValue.RED, 255, 0, 0);
    public static Color GREEN = new Color(ColorValue.GREEN, 0, 255, 0);
    public static Color BLUE = new Color(ColorValue.BLUE, 0, 0, 255);
    public static Color YELLOW = new Color(ColorValue.YELLOW, 255, 255, 0);

    private Color(ColorValue value, int r, int g, int b) {
        Value = value;
        R = r;
        G = g;
        B = b;
    }

    public int[] Rgb() {
        return new int[] { R, G, B };
    }

    public string Hex() {
        return $"#{R:x2}{G:x2}{B:x2}";
    }

    public bool IsDark() {
        return (R + G + B) < 400;
    }
}

public class Program {
    public static void Main() {
        Color color = Color.RED;
        Console.WriteLine($"[{string.Join(", ", color.Rgb())}]");  // [255, 0, 0]
        Console.WriteLine(color.Hex());       // #ff0000
        Console.WriteLine(color.IsDark());    // False
    }
}

Output

[255, 0, 0]
#ff0000
False

Go

enum_with_methods.go

package main

import "fmt"

type Color struct {
  R, G, B int
}

func (c Color) Hex() string {
  return fmt.Sprintf("#%02x%02x%02x", c.R, c.G, c.B)
}

func (c Color) IsDark() bool {
  return (c.R + c.G + c.B) < 400
}

var (
  ColorRED    = Color{255, 0, 0}
  ColorGREEN  = Color{0, 255, 0}
  ColorBLUE   = Color{0, 0, 255}
  ColorYELLOW = Color{255, 255, 0}
)

func main() {
  color := ColorRED
  fmt.Printf("[%d, %d, %d]\n", color.R, color.G, color.B)
  fmt.Println(color.Hex())
  fmt.Println(color.IsDark())
}

Output

[255, 0, 0]
#ff0000
False

Rust

enum_with_methods.rs

struct Color {
    r: u8,
    g: u8,
    b: u8,
}

impl Color {
    fn hex(&self) -> String {
        format!("#{:02x}{:02x}{:02x}", self.r, self.g, self.b)
    }

    fn is_dark(&self) -> bool {
        (self.r as u16 + self.g as u16 + self.b as u16) < 400
    }
}

const COLOR_RED: Color = Color { r: 255, g: 0, b: 0 };
const COLOR_GREEN: Color = Color { r: 0, g: 255, b: 0 };
const COLOR_BLUE: Color = Color { r: 0, g: 0, b: 255 };
const COLOR_YELLOW: Color = Color { r: 255, g: 255, b: 0 };

fn main() {
    let color = COLOR_RED;
    println!("[{}, {}, {}]", color.r, color.g, color.b);
    println!("{}", color.hex());
    println!("{}", color.is_dark());
}

Output

[255, 0, 0]
#ff0000
false

Real-World Example: Order Status

💡 Tip: Click dropdown to switch between languages

Python

Python

order_status_enum.py

from enum import Enum, auto

class OrderStatus(Enum):
    """Order status enum"""
    PENDING = auto()
    CONFIRMED = auto()
    PROCESSING = auto()
    SHIPPED = auto()
    DELIVERED = auto()
    CANCELLED = auto()

    def can_cancel(self):
        """Check if order can be cancelled"""
        return self in [OrderStatus.PENDING, OrderStatus.CONFIRMED]

    def is_completed(self):
        """Check if order is completed"""
        return self == OrderStatus.DELIVERED

    def next_status(self):
        """Get next status in workflow"""
        status_flow = {
            OrderStatus.PENDING: OrderStatus.CONFIRMED,
            OrderStatus.CONFIRMED: OrderStatus.PROCESSING,
            OrderStatus.PROCESSING: OrderStatus.SHIPPED,
            OrderStatus.SHIPPED: OrderStatus.DELIVERED,
        }
        return status_flow.get(self)

class Order:
    def __init__(self, order_id: str):
        self.order_id = order_id
        self.status = OrderStatus.PENDING

    def advance_status(self):
        """Move to next status"""
        next_status = self.status.next_status()
        if next_status:
            self.status = next_status
            return f"Order {self.order_id} moved to {self.status.name}"
        return f"Order {self.order_id} cannot advance from {self.status.name}"

    def cancel(self):
        """Cancel order if possible"""
        if self.status.can_cancel():
            self.status = OrderStatus.CANCELLED
            return f"Order {self.order_id} cancelled"
        return f"Order {self.order_id} cannot be cancelled from {self.status.name}"

# Usage
order = Order("ORD-001")
print(order.status)              # OrderStatus.PENDING
print(order.advance_status())     # Order ORD-001 moved to CONFIRMED
print(order.status)               # OrderStatus.CONFIRMED
print(order.cancel())             # Order ORD-001 cancelled

Output

OrderStatus.PENDING
Order ORD-001 moved to CONFIRMED
OrderStatus.CONFIRMED
Order ORD-001 cancelled

Java

OrderStatusEnum.java

public enum OrderStatus {
    PENDING,
    CONFIRMED,
    PROCESSING,
    SHIPPED,
    DELIVERED,
    CANCELLED;

    public boolean canCancel() {
        return this == PENDING || this == CONFIRMED;
    }

    public boolean isCompleted() {
        return this == DELIVERED;
    }

    public OrderStatus nextStatus() {
        switch (this) {
            case PENDING: return CONFIRMED;
            case CONFIRMED: return PROCESSING;
            case PROCESSING: return SHIPPED;
            case SHIPPED: return DELIVERED;
            default: return null;
        }
    }
}

public class Order {
    private String orderId;
    private OrderStatus status;

    public Order(String orderId) {
        this.orderId = orderId;
        this.status = OrderStatus.PENDING;
    }

    public OrderStatus getStatus() {
        return status;
    }

    public String advanceStatus() {
        OrderStatus nextStatus = this.status.nextStatus();
        if (nextStatus != null) {
            this.status = nextStatus;
            return String.format("Order %s moved to %s", orderId, status.name());
        }
        return String.format("Order %s cannot advance from %s", orderId, status.name());
    }

    public String cancel() {
        if (this.status.canCancel()) {
            this.status = OrderStatus.CANCELLED;
            return String.format("Order %s cancelled", orderId);
        }
        return String.format("Order %s cannot be cancelled from %s", orderId, status.name());
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Order order = new Order("ORD-001");
        System.out.println(order.getStatus());        // PENDING
        System.out.println(order.advanceStatus());    // Order ORD-001 moved to CONFIRMED
        System.out.println(order.getStatus());        // CONFIRMED
        System.out.println(order.cancel());           // Order ORD-001 cancelled
    }
}

Output

PENDING
Order ORD-001 moved to CONFIRMED
CONFIRMED
Order ORD-001 cancelled

TypeScript

order-status-enum.ts

enum OrderStatus {
    PENDING = "PENDING",
    CONFIRMED = "CONFIRMED",
    PROCESSING = "PROCESSING",
    SHIPPED = "SHIPPED",
    DELIVERED = "DELIVERED",
    CANCELLED = "CANCELLED"
}

function canCancel(status: OrderStatus): boolean {
    return status === OrderStatus.PENDING || status === OrderStatus.CONFIRMED;
}

function isCompleted(status: OrderStatus): boolean {
    return status === OrderStatus.DELIVERED;
}

function nextStatus(status: OrderStatus): OrderStatus | null {
    const statusFlow: { [key in OrderStatus]?: OrderStatus } = {
        [OrderStatus.PENDING]: OrderStatus.CONFIRMED,
        [OrderStatus.CONFIRMED]: OrderStatus.PROCESSING,
        [OrderStatus.PROCESSING]: OrderStatus.SHIPPED,
        [OrderStatus.SHIPPED]: OrderStatus.DELIVERED,
    };
    return statusFlow[status] || null;
}

class Order {
    private status: OrderStatus;

    constructor(private orderId: string) {
        this.status = OrderStatus.PENDING;
    }

    getStatus(): OrderStatus {
        return this.status;
    }

    advanceStatus(): string {
        const next = nextStatus(this.status);
        if (next) {
            this.status = next;
            return `Order ${this.orderId} moved to ${this.status}`;
        }
        return `Order ${this.orderId} cannot advance from ${this.status}`;
    }

    cancel(): string {
        if (canCancel(this.status)) {
            this.status = OrderStatus.CANCELLED;
            return `Order ${this.orderId} cancelled`;
        }
        return `Order ${this.orderId} cannot be cancelled from ${this.status}`;
    }
}

// Usage
const order = new Order("ORD-001");
console.log(order.getStatus());        // PENDING
console.log(order.advanceStatus());    // Order ORD-001 moved to CONFIRMED
console.log(order.getStatus());        // CONFIRMED
console.log(order.cancel());           // Order ORD-001 cancelled

Output

PENDING
Order ORD-001 moved to CONFIRMED
CONFIRMED
Order ORD-001 cancelled

C++

order_status_enum.cpp

#include <iostream>
#include <string>
#include <optional>

enum class OrderStatus {
    PENDING,
    CONFIRMED,
    PROCESSING,
    SHIPPED,
    DELIVERED,
    CANCELLED
};

std::string statusToString(OrderStatus status) {
    switch (status) {
        case OrderStatus::PENDING: return "PENDING";
        case OrderStatus::CONFIRMED: return "CONFIRMED";
        case OrderStatus::PROCESSING: return "PROCESSING";
        case OrderStatus::SHIPPED: return "SHIPPED";
        case OrderStatus::DELIVERED: return "DELIVERED";
        case OrderStatus::CANCELLED: return "CANCELLED";
    }
    return "UNKNOWN";
}

bool canCancel(OrderStatus status) {
    return status == OrderStatus::PENDING || status == OrderStatus::CONFIRMED;
}

bool isCompleted(OrderStatus status) {
    return status == OrderStatus::DELIVERED;
}

std::optional<OrderStatus> nextStatus(OrderStatus status) {
    switch (status) {
        case OrderStatus::PENDING: return OrderStatus::CONFIRMED;
        case OrderStatus::CONFIRMED: return OrderStatus::PROCESSING;
        case OrderStatus::PROCESSING: return OrderStatus::SHIPPED;
        case OrderStatus::SHIPPED: return OrderStatus::DELIVERED;
        default: return std::nullopt;
    }
}

class Order {
private:
    std::string orderId;
    OrderStatus status;

public:
    Order(const std::string& id) : orderId(id), status(OrderStatus::PENDING) {}

    OrderStatus getStatus() const {
        return status;
    }

    std::string advanceStatus() {
        auto next = nextStatus(status);
        if (next.has_value()) {
            status = next.value();
            return "Order " + orderId + " moved to " + statusToString(status);
        }
        return "Order " + orderId + " cannot advance from " + statusToString(status);
    }

    std::string cancel() {
        if (canCancel(status)) {
            status = OrderStatus::CANCELLED;
            return "Order " + orderId + " cancelled";
        }
        return "Order " + orderId + " cannot be cancelled from " + statusToString(status);
    }
};

int main() {
    Order order("ORD-001");
    std::cout << statusToString(order.getStatus()) << std::endl;        // PENDING
    std::cout << order.advanceStatus() << std::endl;    // Order ORD-001 moved to CONFIRMED
    std::cout << statusToString(order.getStatus()) << std::endl;        // CONFIRMED
    std::cout << order.cancel() << std::endl;           // Order ORD-001 cancelled

    return 0;
}

Output

PENDING
Order ORD-001 moved to CONFIRMED
CONFIRMED
Order ORD-001 cancelled

C#

OrderStatusEnum.cs

using System;

public enum OrderStatus {
    PENDING,
    CONFIRMED,
    PROCESSING,
    SHIPPED,
    DELIVERED,
    CANCELLED
}

public static class OrderStatusExtensions {
    public static bool CanCancel(this OrderStatus status) {
        return status == OrderStatus.PENDING || status == OrderStatus.CONFIRMED;
    }

    public static bool IsCompleted(this OrderStatus status) {
        return status == OrderStatus.DELIVERED;
    }

    public static OrderStatus? NextStatus(this OrderStatus status) {
        return status switch {
            OrderStatus.PENDING => OrderStatus.CONFIRMED,
            OrderStatus.CONFIRMED => OrderStatus.PROCESSING,
            OrderStatus.PROCESSING => OrderStatus.SHIPPED,
            OrderStatus.SHIPPED => OrderStatus.DELIVERED,
            _ => null
        };
    }
}

public class Order {
    private string orderId;
    private OrderStatus status;

    public Order(string orderId) {
        this.orderId = orderId;
        this.status = OrderStatus.PENDING;
    }

    public OrderStatus GetStatus() {
        return status;
    }

    public string AdvanceStatus() {
        OrderStatus? nextStatus = status.NextStatus();
        if (nextStatus.HasValue) {
            status = nextStatus.Value;
            return $"Order {orderId} moved to {status}";
        }
        return $"Order {orderId} cannot advance from {status}";
    }

    public string Cancel() {
        if (status.CanCancel()) {
            status = OrderStatus.CANCELLED;
            return $"Order {orderId} cancelled";
        }
        return $"Order {orderId} cannot be cancelled from {status}";
    }
}

public class Program {
    public static void Main() {
        Order order = new Order("ORD-001");
        Console.WriteLine(order.GetStatus());        // PENDING
        Console.WriteLine(order.AdvanceStatus());    // Order ORD-001 moved to CONFIRMED
        Console.WriteLine(order.GetStatus());        // CONFIRMED
        Console.WriteLine(order.Cancel());           // Order ORD-001 cancelled
    }
}

Output

PENDING
Order ORD-001 moved to CONFIRMED
CONFIRMED
Order ORD-001 cancelled

Go

order_status_enum.go

package main

import "fmt"

type OrderStatus int

const (
  OrderPending OrderStatus = iota
  OrderConfirmed
 OrderProcessing
 OrderShipped
 OrderDelivered
 OrderCancelled
)

func (s OrderStatus) String() string {
  names := []string{"PENDING", "CONFIRMED", "PROCESSING", "SHIPPED", "DELIVERED", "CANCELLED"}
  return names[s]
}

func (s OrderStatus) CanCancel() bool {
  return s == OrderPending || s == OrderConfirmed
}

func (s OrderStatus) NextStatus() (OrderStatus, bool) {
  switch s {
  case OrderPending:
    return OrderConfirmed, true
  case OrderConfirmed:
    return OrderProcessing, true
  case OrderProcessing:
    return OrderShipped, true
  case OrderShipped:
    return OrderDelivered, true
  default:
    return s, false
  }
}

type Order struct {
  orderID string
  status  OrderStatus
}

func NewOrder(orderID string) *Order {
  return &Order{orderID: orderID, status: OrderPending}
}

func (o *Order) AdvanceStatus() string {
  next, ok := o.status.NextStatus()
  if ok {
    o.status = next
    return fmt.Sprintf("Order %s moved to %s", o.orderID, o.status.String())
  }
  return fmt.Sprintf("Order %s cannot advance from %s", o.orderID, o.status.String())
}

func (o *Order) Cancel() string {
  if o.status.CanCancel() {
    o.status = OrderCancelled
    return fmt.Sprintf("Order %s cancelled", o.orderID)
  }
  return fmt.Sprintf("Order %s cannot be cancelled from %s", o.orderID, o.status.String())
}

func main() {
  order := NewOrder("ORD-001")
  fmt.Println(order.status.String())
  fmt.Println(order.AdvanceStatus())
  fmt.Println(order.status.String())
  fmt.Println(order.Cancel())
}

Output

PENDING
Order ORD-001 moved to CONFIRMED
CONFIRMED
Order ORD-001 cancelled

Rust

order_status_enum.rs

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum OrderStatus {
    Pending,
    Confirmed,
    Processing,
    Shipped,
    Delivered,
    Cancelled,
}

impl OrderStatus {
    fn as_str(self) -> &'static str {
        match self {
            OrderStatus::Pending => "PENDING",
            OrderStatus::Confirmed => "CONFIRMED",
            OrderStatus::Processing => "PROCESSING",
            OrderStatus::Shipped => "SHIPPED",
            OrderStatus::Delivered => "DELIVERED",
            OrderStatus::Cancelled => "CANCELLED",
        }
    }

    fn can_cancel(self) -> bool {
        matches!(self, OrderStatus::Pending | OrderStatus::Confirmed)
    }

    fn next_status(self) -> Option<OrderStatus> {
        match self {
            OrderStatus::Pending => Some(OrderStatus::Confirmed),
            OrderStatus::Confirmed => Some(OrderStatus::Processing),
            OrderStatus::Processing => Some(OrderStatus::Shipped),
            OrderStatus::Shipped => Some(OrderStatus::Delivered),
            _ => None,
        }
    }
}

struct Order {
    order_id: String,
    status: OrderStatus,
}

impl Order {
    fn new(order_id: impl Into<String>) -> Self {
        Self {
            order_id: order_id.into(),
            status: OrderStatus::Pending,
        }
    }

    fn advance_status(&mut self) -> String {
        if let Some(next) = self.status.next_status() {
            self.status = next;
            format!("Order {} moved to {}", self.order_id, self.status.as_str())
        } else {
            format!(
                "Order {} cannot advance from {}",
                self.order_id,
                self.status.as_str()
            )
        }
    }

    fn cancel(&mut self) -> String {
        if self.status.can_cancel() {
            self.status = OrderStatus::Cancelled;
            format!("Order {} cancelled", self.order_id)
        } else {
            format!(
                "Order {} cannot be cancelled from {}",
                self.order_id,
                self.status.as_str()
            )
        }
    }
}

fn main() {
    let mut order = Order::new("ORD-001");
    println!("{}", order.status.as_str());
    println!("{}", order.advance_status());
    println!("{}", order.status.as_str());
    println!("{}", order.cancel());
}

Output

PENDING
Order ORD-001 moved to CONFIRMED
CONFIRMED
Order ORD-001 cancelled

Enum Iteration

You can iterate over all enum values:

💡 Tip: Click dropdown to switch between languages

Python

Python

enum_iteration.py

from enum import Enum

class Day(Enum):
    MONDAY = 1
    TUESDAY = 2
    WEDNESDAY = 3
    THURSDAY = 4
    FRIDAY = 5
    SATURDAY = 6
    SUNDAY = 7

# Iterate over all enum values
for day in Day:
    print(f"{day.name}: {day.value}")

# Check if value exists
print(Day.MONDAY in Day)  # True
print(Day(1) == Day.MONDAY)  # True

Output

MONDAY: 1
TUESDAY: 2
WEDNESDAY: 3
THURSDAY: 4
FRIDAY: 5
SATURDAY: 6
SUNDAY: 7
True
True

Java

EnumIteration.java

public enum Day {
    MONDAY(1),
    TUESDAY(2),
    WEDNESDAY(3),
    THURSDAY(4),
    FRIDAY(5),
    SATURDAY(6),
    SUNDAY(7);

    private final int value;

    Day(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        // Iterate over all enum values
        for (Day day : Day.values()) {
            System.out.println(day.name() + ": " + day.getValue());
        }

        // Check if value exists
        System.out.println(Day.MONDAY == Day.valueOf("MONDAY"));  // true
    }
}

Output

MONDAY: 1
TUESDAY: 2
WEDNESDAY: 3
THURSDAY: 4
FRIDAY: 5
SATURDAY: 6
SUNDAY: 7
true

TypeScript

enum-iteration.ts

enum Day {
    MONDAY = 1,
    TUESDAY = 2,
    WEDNESDAY = 3,
    THURSDAY = 4,
    FRIDAY = 5,
    SATURDAY = 6,
    SUNDAY = 7
}

// Iterate over all enum values
Object.keys(Day).filter(key => isNaN(Number(key))).forEach(day => {
    console.log(`${day}: ${Day[day as keyof typeof Day]}`);
});

// Check if value exists
console.log(Day.MONDAY === Day.MONDAY);  // true
console.log(Day[1] === "MONDAY");        // true

Output

MONDAY: 1
TUESDAY: 2
WEDNESDAY: 3
THURSDAY: 4
FRIDAY: 5
SATURDAY: 6
SUNDAY: 7
true
true

C++

enum_iteration.cpp

#include <iostream>
#include <string>
#include <vector>

enum class Day {
    MONDAY = 1,
    TUESDAY = 2,
    WEDNESDAY = 3,
    THURSDAY = 4,
    FRIDAY = 5,
    SATURDAY = 6,
    SUNDAY = 7
};

std::string dayToString(Day day) {
    switch (day) {
        case Day::MONDAY: return "MONDAY";
        case Day::TUESDAY: return "TUESDAY";
        case Day::WEDNESDAY: return "WEDNESDAY";
        case Day::THURSDAY: return "THURSDAY";
        case Day::FRIDAY: return "FRIDAY";
        case Day::SATURDAY: return "SATURDAY";
        case Day::SUNDAY: return "SUNDAY";
    }
    return "UNKNOWN";
}

int main() {
    // Iterate over all enum values
    std::vector<Day> days = {
        Day::MONDAY, Day::TUESDAY, Day::WEDNESDAY,
        Day::THURSDAY, Day::FRIDAY, Day::SATURDAY, Day::SUNDAY
    };

    for (const auto& day : days) {
        std::cout << dayToString(day) << ": " << static_cast<int>(day) << std::endl;
    }

    // Check if value exists
    std::cout << (Day::MONDAY == Day::MONDAY) << std::endl;  // 1 (true)
    std::cout << (static_cast<int>(Day::MONDAY) == 1) << std::endl;  // 1 (true)

    return 0;
}

Output

MONDAY: 1
TUESDAY: 2
WEDNESDAY: 3
THURSDAY: 4
FRIDAY: 5
SATURDAY: 6
SUNDAY: 7
1
1

C#

EnumIteration.cs

using System;

public enum Day {
    MONDAY = 1,
    TUESDAY = 2,
    WEDNESDAY = 3,
    THURSDAY = 4,
    FRIDAY = 5,
    SATURDAY = 6,
    SUNDAY = 7
}

public class Program {
    public static void Main() {
        // Iterate over all enum values
        foreach (Day day in Enum.GetValues(typeof(Day))) {
            Console.WriteLine($"{day}: {(int)day}");
        }

        // Check if value exists
        Console.WriteLine(Day.MONDAY == Day.MONDAY);           // True
        Console.WriteLine(Enum.IsDefined(typeof(Day), 1));     // True
    }
}

Output

MONDAY: 1
TUESDAY: 2
WEDNESDAY: 3
THURSDAY: 4
FRIDAY: 5
SATURDAY: 6
SUNDAY: 7
True
True

Go

enum_iteration.go

package main

import "fmt"

type Day int

const (
  MONDAY Day = iota + 1
  TUESDAY
  WEDNESDAY
  THURSDAY
  FRIDAY
  SATURDAY
  SUNDAY
)

func (d Day) String() string {
  names := []string{"MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY", "SATURDAY", "SUNDAY"}
  return names[d-1]
}

func dayDefined(v int) bool {
  return v >= int(MONDAY) && v <= int(SUNDAY)
}

func main() {
  for d := MONDAY; d <= SUNDAY; d++ {
    fmt.Printf("%s: %d\n", d.String(), int(d))
  }
  fmt.Println(MONDAY == MONDAY)
  fmt.Println(dayDefined(1))
}

Output

MONDAY: 1
TUESDAY: 2
WEDNESDAY: 3
THURSDAY: 4
FRIDAY: 5
SATURDAY: 6
SUNDAY: 7
true
true

Rust

enum_iteration.rs

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
enum Day {
    Monday = 1,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
    Sunday,
}

impl Day {
    fn name(self) -> &'static str {
        match self {
            Day::Monday => "MONDAY",
            Day::Tuesday => "TUESDAY",
            Day::Wednesday => "WEDNESDAY",
            Day::Thursday => "THURSDAY",
            Day::Friday => "FRIDAY",
            Day::Saturday => "SATURDAY",
            Day::Sunday => "SUNDAY",
        }
    }
}

fn day_defined(v: i32) -> bool {
    (Day::Monday as i32..=Day::Sunday as i32).contains(&v)
}

fn main() {
    for day in [
        Day::Monday,
        Day::Tuesday,
        Day::Wednesday,
        Day::Thursday,
        Day::Friday,
        Day::Saturday,
        Day::Sunday,
    ] {
        println!("{}: {}", day.name(), day as i32);
    }
    println!("{}", Day::Monday == Day::Monday);
    println!("{}", day_defined(1));
}

Output

MONDAY: 1
TUESDAY: 2
WEDNESDAY: 3
THURSDAY: 4
FRIDAY: 5
SATURDAY: 6
SUNDAY: 7
true
true

Visual Representation

Key Takeaways

Remember

• Enums provide type-safe named constants
• Python: Use Enum or IntEnum from the enum module
• Java: Use enum keyword (special class type)
• Enums can have methods and properties
• Enums improve readability and maintainability
• Use enums instead of magic numbers or strings
• Enums can be iterated over all values
• Enums provide type safety - prevents invalid values

When to Use Enums

Use enums when:

• You have a fixed set of related constants
• You want type safety (prevent invalid values)
• You need self-documenting code
• Values won’t change frequently
• You want better IDE support

Examples:

• Status values (PENDING, ACTIVE, INACTIVE)
• Days of the week
• Colors
• Priority levels
• Error codes
• Configuration options