· 1 min read
This time I’m going to show you a behavioral pattern. Here is a little example of the command design patten written in Swift.
The command pattern can be handy if you’d like to provide a common interface for different actions that will be executed later in time. Usually it’s an object that encapsulates all the information needed to run the underlying action properly.
Commands are often used to handle user interface actions, create undo managers, or manage transactions. Let’s see a command pattern implementation in Swift by creating a command line argument handler with emojis. 💾
#!/usr/bin/env swift
import Foundation
protocol Command {
func execute()
}
class HelpCommand: Command {
func execute() {
Help().info()
}
}
class Help {
func info() {
print("""
🤖 Commander 🤖
v1.0
Available commands:
👉 help This command
👉 ls List documents
Bye! 👋
""")
}
}
class ListCommand: Command {
func execute() {
List().homeDirectoryContents()
}
}
class List {
func homeDirectoryContents() {
let fileManager = FileManager.default
guard let documentsURL = fileManager.urls(for: .documentDirectory, in: .userDomainMask).first else {
print("Could not open documents directory")
exit(-1)
}
do {
let fileURLs = try fileManager.contentsOfDirectory(at: documentsURL, includingPropertiesForKeys: nil)
print("\n\t📁 Listing documents directory:\n")
print(fileURLs.map { "\t\t💾 " + $0.lastPathComponent }.joined(separator: "\n\n") + "\n" )
}
catch {
print(error.localizedDescription)
exit(-1)
}
}
}
class App {
var commands: [String:Command] = [:]
init() {
self.commands["help"] = HelpCommand()
self.commands["ls"] = ListCommand()
}
func run() {
let arguments = CommandLine.arguments[1...]
guard let key = arguments.first, self.commands[key] != nil else {
print("Usage: ./command.swift [\(self.commands.keys.joined(separator: "|"))]")
exit(-1)
}
self.commands[key]!.execute()
}
}
App().run()
If you save this file, can run it by simply typing ./file-name.swift from a terminal window. The Swift compiler will take care of the rest.
Real world use cases for the command design pattern:
+ various button actions
+ collection / table view selection actions
+ navigating between controllers
+ history management / undo manager
+ transactional behavior
+ progress management
+ wizards
As you can see this pattern can be applied in multiple areas. Apple even made a specific class for this purpose called NSInvocation, but unfortunately it’s not available in Swift, due to it’s dynamic behavior. That’s not a big deal, you can always make your own protocol & implementation, in most cases you just need one extra class that wraps the underlying command logic. 😛
Related posts
· 6 min read
In this article I am going to show you how to implement a basic event processing system for your modular Swift application.
· 4 min read
Learn the iterator design pattern by using some custom sequences, conforming to the IteratorProtocol from the Swift standard library.
· 4 min read
Learn how to use lazy properties in Swift to improve performance, avoid optionals or just to make the init process more clean.
· 5 min read
Beginner’s guide about optics in Swift. Learn how to use lenses and prisms to manipulate objects using a functional approach.