Design Patterns in Swift: Build Better Apps with Reusable Code

By /

Design Patterns in Swift: Build Better Apps with Reusable Code

Swift is a powerful and intuitive programming language used to create apps for iOS, MacOS, watchOS, and tvOS. With its modern syntax, Swift makes it easy to create powerful and efficient apps. But as your app becomes more complex, it can be difficult to structure your code in an organized way. That’s where design patterns come in.

Design patterns are reusable solutions to common programming problems. By using them, you can structure your code in a more logical way, making it easier to read and maintain. In this article, we’ll explore the most common design patterns used in Swift.

Model-View-Controller (MVC)

The Model-View-Controller (MVC) pattern is one of the most popular design patterns used in software development. It divides your app into three distinct layers: the model, the view, and the controller.

The model layer contains the data and business logic of your app. This includes objects such as user accounts, messages, and posts. The view layer displays the data from the model layer. It also handles user interaction, such as button presses and text input. Finally, the controller layer acts as the intermediary between the model and view layers. It retrieves data from the model layer and updates the view layer accordingly.

Here’s an example of the MVC pattern in action. We’ll create a simple app that displays a list of users.

// Model 
struct User { 
    let name: String 
    let age: Int 
} 

// View 
class UserListView { 
    func showUsers(_ users: [User]) { 
        for user in users { 
            print("\(user.name): \(user.age)") 
        } 
    } 
} 

// Controller 
class UserListController { 
    let view: UserListView 
    let users: [User] 

    init(view: UserListView, users: [User]) { 
        self.view = view 
        self.users = users 
    } 

    func showUsers() { 
        view.showUsers(users) 
    } 
} 

// Create the view and the model 
let users = [User(name: "John", age: 20), User(name: "Jane", age: 22)] 
let userListView = UserListView() 

// Create the controller 
let userListController = UserListController(view: userListView, users: users) 

// Show the users 
userListController.showUsers() 
/* Output: 
John: 20 
Jane: 22 */

In this example, we have a model layer represented by the User struct. The view layer is represented by the UserListView class, which displays the list of users. Finally, the controller layer is represented by the UserListController class, which retrieves the list of users from the model layer and updates the view layer accordingly.

Delegation

The delegation pattern is another popular design pattern used in software development. It allows one object (the delegate) to handle the tasks of another object (the delegator).

Let’s look at an example. We’ll create a simple app that displays a list of users. The app will use the delegation pattern to handle the task of displaying the list of users.

// Protocol 
protocol UserListDelegate { 
    func showUsers(_ users: [User]) 
} 

// Model 
struct User { 
    let name: String 
    let age: Int 
} 

// View 
class UserListView { 
    var delegate: UserListDelegate? 

    func showUsers() { 
        // Retrieve the list of users 
        let users = [User(name: "John", age: 20), User(name: "Jane", age: 22)] 

        // Call the delegate 
        delegate?.showUsers(users) 
    } 
} 

// Delegate 
class UserListDelegateImpl: UserListDelegate { 
    func showUsers(_ users: [User]) { 
        for user in users { 
            print("\(user.name): \(user.age)") 
        } 
    } 
} 

// Create the view and the delegate 
let userListView = UserListView() 
let userListDelegate = UserListDelegateImpl() 

// Set the delegate 
userListView.delegate = userListDelegate 

// Show the users 
userListView.showUsers() 
/* Output: 
John: 20 
Jane: 22 */

In this example, the UserListView class is the delegator. It delegates the task of displaying the list of users to the UserListDelegateImpl class, which is the delegate. The UserListDelegateImpl class implements the UserListDelegate protocol, which defines the showUsers(_:) method. This method is used to display the list of users.

Singleton

The singleton pattern is a design pattern used to ensure that only one instance of a class is created. This is useful when you need to share data or resources across multiple parts of your app.

Let’s look at an example. We’ll create a simple app that logs messages to the console. The app will use the singleton pattern to ensure that only one instance of the Logger class is created. 

class Logger { 
    static let shared = Logger() 

    private init() {} 

    func log(_ message: String) { 
        print(message) 
    } 
} 

// Use the logger 
Logger.shared.log("Hello World!") 
/* Output: 
Hello World! */

In this example, the Logger class is declared with the static keyword. This ensures that only one instance of the Logger class is created. To access the shared instance of the Logger class, we use the Logger.shared property. We can then call the log(_:) method on the shared instance to log a message to the console.

Conclusion

Design patterns are an important tool for structuring your code in an organized way. In this article, we’ve explored the most common design patterns used in Swift: the Model-View-Controller (MVC) pattern, the delegation pattern, and the singleton pattern. By using these patterns, you can create more efficient and maintainable apps.

Using design patterns can be difficult at first, but with practice, you’ll be able to use them effectively in your apps. So don’t be afraid to experiment and try out different patterns in your code. Good luck!

Scroll to Top