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 used for iOS, macOS, watchOS and tvOS development. Its simple, yet powerful syntax makes it an ideal choice for developers to quickly build and ship their applications. As such, many developers are turning to Swift to create robust and efficient applications.

At the same time, they’re also looking for ways to make their code more manageable and easier to maintain. One way of achieving this is by using design patterns. Design patterns provide a structure for code that can be reused and adapted to different scenarios. One of the most popular design patterns is the state pattern.

The state pattern is a behavioral design pattern that allows an object to change its behavior when its internal state changes. This means that, depending on the situation, the same object can behave differently. The state pattern is useful for managing complex states and transitions between them. It also helps to reduce the complexity of code by encapsulating state-specific logic.

In this article, we’ll take a look at how to use the state pattern in Swift. We’ll start by discussing what the state pattern is and why it’s useful. Then, we’ll move on to creating an example application that uses the state pattern. Finally, we’ll look at how to apply the state pattern in a real-world project.

What is the State Pattern?

The state pattern is a type of behavioral design pattern that enables an object to change its behavior when its internal state changes. This means that the same object can respond differently in different situations. As a result, it’s useful for managing complex states and transitions between them.

For example, consider a vending machine. Depending on the situation, it can behave differently. If there is no money inserted, it will not dispense items. If there is money inserted, it will dispense items. In this case, the vending machine’s internal state (i.e., whether or not money has been inserted) determines its behavior.

Why Use the State Pattern?

Using the state pattern can help to reduce the complexity of code by encapsulating state-specific logic. By separating out the logic for each state, it’s easier to manage and maintain. It also makes it easier to extend the system with new states and transitions.

The state pattern also helps to keep the code DRY (Don’t Repeat Yourself). Instead of having to write the same logic over and over again, it can be encapsulated into a single state object. This makes the code more concise and easier to maintain.

Creating a Sample Application

Let’s take a look at how to use the state pattern in Swift. We’ll build a sample application called “Vending Machine” that uses the state pattern to manage the different states and transitions.

First, we’ll create a class called “VendingMachine” that contains the logic for our vending machine. The class will have two properties: one for the current state and one for the total amount of money inserted.

class VendingMachine {
    var currentState: State
    var totalAmountInserted: Int
    
    init(initialState: State) {
        self.currentState = initialState
        self.totalAmountInserted = 0
    }
}

Next, we’ll create a protocol called “State” that our state classes will conform to. This protocol will define the behavior of our states. It will contain three functions: insertMoney(), selectItem() and dispenseItem(). 

protocol State {
    func insertMoney(amount: Int)
    func selectItem(itemNumber: Int)
    func dispenseItem()
}

Now, we’ll create the states for our vending machine. The first state is the “NoMoneyInsertedState”. This state is used when no money has been inserted into the vending machine. It will handle the logic for inserting money.

class NoMoneyInsertedState: State {
    private let vendingMachine: VendingMachine

    init(vendingMachine: VendingMachine) {
        self.vendingMachine = vendingMachine
    }

    func insertMoney(amount: Int) {
        vendingMachine.totalAmountInserted += amount
        vendingMachine.currentState = MoneyInsertedState(vendingMachine: vendingMachine)
    }

    func selectItem(itemNumber: Int) {
        print("You must insert money first!")
    }

    func dispenseItem() {
        print("You must insert money first!")
    }
}

The next state is the “MoneyInsertedState”. This state is used when money has been inserted into the vending machine. It will handle the logic for selecting and dispensing items.

class MoneyInsertedState: State {
    private let vendingMachine: VendingMachine

    init(vendingMachine: VendingMachine) {
        self.vendingMachine = vendingMachine
    }

    func insertMoney(amount: Int) {
        vendingMachine.totalAmountInserted += amount
    }

    func selectItem(itemNumber: Int) {
        vendingMachine.currentState = ItemSelectedState(vendingMachine: vendingMachine, itemNumber: itemNumber)
    }

    func dispenseItem() {
        print("You must select an item first!")
    }
}

Finally, we’ll create the “ItemSelectedState”. This state is used when an item has been selected. It will handle the logic for dispensing items.

class ItemSelectedState: State {
    private let vendingMachine: VendingMachine
    private let itemNumber: Int

    init(vendingMachine: VendingMachine, itemNumber: Int) {
        self.vendingMachine = vendingMachine
        self.itemNumber = itemNumber
    }

    func insertMoney(amount: Int) {
        vendingMachine.totalAmountInserted += amount
    }

    func selectItem(itemNumber: Int) {
        print("You must dispense the current item first!")
    }

    func dispenseItem() {
        if vendingMachine.totalAmountInserted >= 10 {
            print("Here is your item number \(itemNumber)")
            vendingMachine.currentState = NoMoneyInsertedState(vendingMachine: vendingMachine)
        } else {
            print("You must insert more money!")
        }
    }
}

Now that we have our states set up, we can use them in our vending machine. To do this, we’ll create an instance of the VendingMachine class and set its initial state to NoMoneyInsertedState.

let vendingMachine = VendingMachine(initialState: NoMoneyInsertedState(vendingMachine: vendingMachine))

Then, we can test our vending machine by calling its methods. For example, we can call the insertMoney() method to insert money into the vending machine.

vendingMachine.insertMoney(amount: 10)

We can also call the selectItem() and dispenseItem() methods to select and dispense items. 

vendingMachine.selectItem(itemNumber: 1)
vendingMachine.dispenseItem()

Using the State Pattern in a Real-World Project

Now that we’ve seen how to use the state pattern in a sample application, let’s take a look at how it can be applied in a real-world project.

One example of the state pattern being used in a real-world project is in the development of a mobile game. Mobile games often have complex state machines that control the flow of the game. For example, a game may have states for the main menu, the game itself, and the end game screen. The state pattern can be used to manage these states and transitions between them.

Another example is in the development of a web application. Web applications often have complex user flows that need to be managed. The state pattern can be used to encapsulate the logic for each user flow into separate states. This makes the code more manageable and easier to maintain.

Conclusion

In this article, we took a look at how to use the state pattern in Swift. We discussed what the state pattern is and why it’s useful. Then, we created a sample application that used the state pattern to manage different states and transitions. Finally, we looked at how to apply the state pattern in a real-world project.

Using the state pattern can help to reduce the complexity of code by encapsulating state-specific logic. It also helps to keep the code DRY and makes it easier to extend the system with new states and transitions. As such, it’s a useful tool for managing complex states and transitions.

Scroll to Top