设计模式(Swift) - 2.单例模式、备忘录模式和策略模式

2024-02-19 12:55:53

单例模式、备忘录模式和策略模式：Swift 中的实用设计模式

单例模式

单例模式确保了一个类只有一个实例，并提供了一个全局访问点。它常用于管理资源，例如数据库连接或全局变量。

在 Swift 中，可以通过两种方法实现单例模式：

全局变量：

class Singleton {
    static let shared = Singleton()
    private init() {}
}

静态属性：

class Singleton {
    static var shared: Singleton {
        get {
            if sharedInstance == nil {
                sharedInstance = Singleton()
            }
            return sharedInstance!
        }
    }

    private init() {}
    private static var sharedInstance: Singleton?
}

备忘录模式

备忘录模式存储一个对象的当前状态，以便在需要时还原到该状态。它常用于保存复杂对象的快照或实现撤销操作。

在 Swift 中，备忘录模式可以通过以下两种方式实现：

归档/解归档：

class Memento {
    private let state: String

    init(state: String) {
        self.state = state
    }

    func getState() -> String {
        return state
    }
}

class Originator {
    private var state: String

    init(state: String) {
        self.state = state
    }

    func setState(state: String) {
        self.state = state
    }

    func saveState() -> Memento {
        return Memento(state: state)
    }

    func restoreState(memento: Memento) {
        state = memento.getState()
    }
}

快照：

class Memento {
    private let snapshot: [String: Any]

    init(snapshot: [String: Any]) {
        self.snapshot = snapshot
    }

    func getSnapshot() -> [String: Any] {
        return snapshot
    }
}

class Originator {
    private var state: [String: Any]

    init(state: [String: Any]) {
        self.state = state
    }

    func setState(state: [String: Any]) {
        self.state = state
    }

    func saveState() -> Memento {
        return Memento(snapshot: state)
    }

    func restoreState(memento: Memento) {
        state = memento.getSnapshot()
    }
}

策略模式

策略模式允许算法的行为在不改变客户端的情况下发生变化。它通过分离算法和客户端来实现，使客户端能够动态地选择不同的算法。

在 Swift 中，策略模式可以通过以下两种方式实现：

枚举：

enum Strategy {
    case a, b, c
}

class Context {
    private var strategy: Strategy

    init(strategy: Strategy) {
        self.strategy = strategy
    }

    func executeStrategy() {
        switch strategy {
            case .a:
                // Do something
                break
            case .b:
                // Do something else
                break
            case .c:
                // Do something else
                break
        }
    }
}

闭包：

typealias Strategy = (Int, Int) -> Int

class Context {
    private var strategy: Strategy

    init(strategy: Strategy) {
        self.strategy = strategy
    }

    func executeStrategy(a: Int, b: Int) -> Int {
        return strategy(a, b)
    }
}