Swift Enum: Syntax, Usage, and Examples

Enums in Swift define a group of related values under a single type. They help you write safer, more readable code by eliminating magic numbers and strings. Unlike enums in some other languages, Swift enums can store associated values and methods, making them highly flexible. They also support raw values and can conform to protocols, which enhances their usability across different programming scenarios.

How to Use Enums in Swift

Enums use the enum keyword followed by a list of cases. Each case represents a possible value.

enum Direction {
    case north
    case south
    case east
    case west
}

Assigning Enum Values

You can assign an enum value to a variable or constant using dot notation.

let currentDirection: Direction = .west

If the type is already known, you can omit the enum name for brevity.

var nextMove = Direction.east

Switching on Enum Cases

Using a switch statement with enums makes handling different cases easy and eliminates the need for lengthy if statements.

switch currentDirection {
case .north:
    print("Heading north")
case .south:
    print("Heading south")
case .east:
    print("Heading east")
case .west:
    print("Heading west")
}

Since Swift requires switch statements to be exhaustive, you must cover all cases or use a default case.

When to Use Enums in Swift

Enums help eliminate hardcoded values and make your code more maintainable. They are useful in several scenarios, including defining states, handling API responses, and managing configurations.

Grouping Related Values

Enums allow you to replace strings or integers when defining a set of possible values. Instead of using "monday", "tuesday", and so on, you can use an enum for better safety.

enum Day {
    case monday, tuesday, wednesday, thursday, friday, saturday, sunday
}

Handling API Responses

Enums make handling API responses structured by replacing status codes or response strings with well-defined cases.

enum StatusCode {
    case success
    case error
    case loading
}

This approach reduces the risk of typos and makes response handling more predictable.

Defining State Machines

Enums work well for managing state in an application. For example, you can use an enum to track a user’s authentication state.

enum AuthState {
    case loggedIn, loggedOut, inProgress
}

Examples of Enums in Swift

Using Enums with Raw Values

You can assign raw values to enums, which is useful when storing integer or string representations of a case.

enum HTTPStatus: Int {
    case ok = 200
    case notFound = 404
    case serverError = 500
}

let responseCode = HTTPStatus.ok.rawValue
print(responseCode) // Output: 200

Enums with Associated Values

Enums can store associated values, allowing you to attach additional data to each case.

enum Payment {
    case cash(amount: Double)
    case card(number: String, expiry: String)
}

let transaction = Payment.card(number: "1234-5678-9012-3456", expiry: "12/24")

switch transaction {
case .cash(let amount):
    print("Paid in cash: \(amount)")
case .card(let number, let expiry):
    print("Paid with card ending in \(number.suffix(4)), expires \(expiry)")
}

This feature allows you to store different data types within a single enum.

Enum Methods

You can define methods inside an enum to add behavior directly to its cases.

enum TrafficLight {
    case red, yellow, green

    func description() -> String {
        switch self {
        case .red:
            return "Stop"
        case .yellow:
            return "Slow down"
        case .green:
            return "Go"
        }
    }
}

let light = TrafficLight.red
print(light.description()) // Output: Stop

Adding methods to enums helps keep related logic together, improving code organization.

Comparing Enums

You can compare enum values using the equality operator.

if light == .red {
    print("You must stop.")
}

This ensures type safety since only valid cases can be compared.

Learn More About Enums in Swift

Swift enums offer additional features like default values, protocol conformance, and computed properties.

Enum with Default Values

If an enum has raw values, you can initialize an instance using init(rawValue:). This allows you to convert external data into an enum safely.

enum SeatClass: String {
    case economy = "Economy"
    case business = "Business"
    case first = "First Class"
}

let chosenSeat = SeatClass(rawValue: "Business")

If the provided raw value doesn’t match any case, the initializer returns nil, which makes it useful for handling unknown data.

Enum with Protocols

Enums can conform to protocols, enabling shared behavior across different types.

protocol Printable {
    func printValue()
}

enum Vehicle: Printable {
    case car, bike, bus

    func printValue() {
        print(self)
    }
}

let myVehicle = Vehicle.car
myVehicle.printValue() // Output: car

This technique allows enums to work seamlessly with other types in your code.

Using Enums as Function Parameters

Passing enums as function parameters ensures type safety and improves code clarity.

func setTheme(_ theme: Theme) {
    switch theme {
    case .dark:
        print("Dark mode activated")
    case .light:
        print("Light mode activated")
    }
}

enum Theme {
    case dark, light
}

setTheme(.dark)

This method prevents invalid values from being passed to functions, reducing bugs.

Enums Inside Classes

Enums can be nested within classes or structs, making them more modular.

class Car {
    enum Transmission {
        case manual, automatic
    }

    let transmission: Transmission

    init(transmission: Transmission) {
        self.transmission = transmission
    }
}

let myCar = Car(transmission: .automatic)

By nesting enums, you can keep related data encapsulated within its relevant context.

Best Practices for Using Enums

• Use camelCase for enum cases (case active instead of case ACTIVE).
• Prefer switch statements over ifelse for handling enum values.
• Store associated values instead of separate variables when relevant.
• Use raw values only when necessary (e.g., mapping to API values).
• Consider protocol conformance if you need shared behavior across enums.