Design Patterns in Swift: Mastering the State Pattern

By /

Design Patterns in Swift: Mastering the State Pattern

Swift is a powerful and versatile programming language, and mastering its design patterns can help you become a better developer. One of the most important design patterns is the state pattern, which can be used to create flexible and maintainable code. In this article, we’ll explore the basics of the state pattern and how it can be applied in Swift.

The state pattern is a behavioral design pattern that allows an object to change its behavior based on its internal state. By using the state pattern, you can separate the logic responsible for handling a particular state from the rest of the code. This makes it easier to maintain and extend your codebase, as well as reduce complexity by keeping related logic together.

The state pattern is especially useful when dealing with complex objects that have many different states. For example, a game character might have different states such as “running”, “jumping”, and “falling”. Each of these states would be handled by a different class, making it easy to modify or add new states without affecting the existing code.

In Swift, the state pattern can be implemented using protocols and classes. The protocol defines the behavior of the state, while the class is responsible for managing the state and providing the appropriate response. To demonstrate how this works, let’s look at a simple example.

We’ll create a game character that can move left, right, jump, and fall. We’ll start by creating a protocol that defines the behavior for each state: 

protocol GameCharacterState {
    func moveLeft()
    func moveRight()
    func jump()
    func fall()
}

Next, we’ll create a class to manage the current state of the game character. This class will be responsible for tracking the current state and providing the appropriate response when a method is called: 

class GameCharacter {
    
    private var state: GameCharacterState
    
    init(state: GameCharacterState) {
        self.state = state
    }
    
    func moveLeft() {
        state.moveLeft()
    }
    
    func moveRight() {
        state.moveRight()
    }
    
    func jump() {
        state.jump()
    }
    
    func fall() {
        state.fall()
    }
    
    func setState(state: GameCharacterState) {
        self.state = state
    }
}

Finally, we’ll create a concrete class for each state. Each class must conform to the GameCharacterState protocol and provide an implementation for each of the required methods: 

class RunningState: GameCharacterState {
    func moveLeft() {
        print("Moving Left")
    }
    
    func moveRight() {
        print("Moving Right")
    }
    
    func jump() {
        print("Jumping")
    }
    
    func fall() {
        print("Falling")
    }
}

class JumpingState: GameCharacterState {
    func moveLeft() {
        print("Cannot move left while jumping")
    }
    
    func moveRight() {
        print("Cannot move right while jumping")
    }
    
    func jump() {
        print("Cannot jump while jumping")
    }
    
    func fall() {
        print("Falling")
    }
}

class FallingState: GameCharacterState {
    func moveLeft() {
        print("Cannot move left while falling")
    }
    
    func moveRight() {
        print("Cannot move right while falling")
    }
    
    func jump() {
        print("Cannot jump while falling")
    }
    
    func fall() {
        print("Falling")
    }
}

Now that we have all the pieces in place, let’s see how we can use them to create a game character. First, we’ll create an instance of the GameCharacter class and give it an initial state: 

let character = GameCharacter(state: RunningState())

We can then call the various methods on the character to make it move, jump, and fall: 

character.moveLeft() // Moving Left
character.jump() // Jumping
character.fall() // Falling

We can also change the character’s state at any time by calling the setState() method: 

character.setState(state: JumpingState())
character.moveLeft() // Cannot move left while jumping

By using the state pattern, we’ve created a game character that can easily transition between different states without having to write complex and convoluted code. This makes it easier to maintain and extend our codebase, as well as reduce complexity by keeping related logic together.

In this article, we’ve looked at the basics of the state pattern and how it can be applied in Swift. We’ve seen how the pattern can be used to create flexible and maintainable code, and how it can help reduce complexity by separating related logic. By mastering this pattern, you can become a better developer and create more robust and efficient code.

Scroll to Top