最近几天我一直在与 Swift 上的泛型相关的一些问题作斗争，但我没有找到解决这个问题的方法:

• 我有一个类(class) class Store<S: State>其中 State是一个扩展 Equatable protocol State: Equatable 的简单协议(protocol).
• 我有一个类(class) Logger我想存储 Stores 数组的位置跟踪它们的每个变化并比较它们的 State使用它们的旧值，能够检查每次迭代中发生了什么变化。

为此，我需要在我的记录器类中存储一组 Any Kind of Store。当我尝试使用 val storeArray = [Store<Any>] 时问题就来了，它不起作用，因为 Any 不是 Equatable类型，我需要它们来扩展 Equatable或 NSObject以便能够比较它们之间的状态。

有可能在 Swift 中实现吗？或者找出另一种方法来比较 2 个项目，而无需进行通用扩展 Equatable协议(protocol)？

如果您想检查实现:

状态:

protocol State: Equatable {
}

商店:

class Store<S: State> {

    private var _initialState: S
    private var _state: S
    private var processor = PublishSubject<S>()

    init(initialState: S) {
        _initialState = initialState
        _state = initialState
    }

    var state: S {
        get {
            return _state
        }
        set(value) {
            if (value != state) {
                _state = value
                processor.onNext(value)
            }
        }
    }

    func initialState() -> S {
        return _initialState
    }

    /// Initialize the store. Called after all stores instances are ready.
    func initialize() {
        //TODO Check if its possible to force an override over a method
        preconditionFailure("This method must be overridden")
    }
}

根据 Vadian 的建议，我尝试将其移动到具有关联类型的协议(protocol):

protocol Store: class {
    associatedtype State : StateDelegate
    var processor : PublishSubject<State> { get }
    var _state : State { get set }
    var state: State { get set }
    func initialState() -> State
    func flowable() -> Observable<State>
    func initialize() -> Void
}

extension Store {

    var state: State {
        get {
            return _state
        }
        set(value) {
            if (value != state) {
                _state = value
                processor.onNext(value)
            }
        }
    }

    func flowable() -> Observable<State> {
        return processor.startWith(state)
    }

    func initialState() -> State {
        return State.init()
    }
}

但是当我尝试创建 [Store] 时，我检索到下一个错误大批: Protocol 'Store' can only be used as a generic constraint because it has Self or associated type requirements

最佳答案

我想我现在明白你的问题了。这个解决方案怎么样:

不是让 State 符合 Equatable，而是将您自己的自定义相等性检查添加到协议(protocol)中；通过这种方式，您可以将状态存储在一个数组中 (var states: [State])。缺点是您不能使用泛型，而是必须在代码中进行类型检查，就像过去的美好时光一样。

例如，State 协议(protocol)的一个简单版本:

protocol State {
  func isEqualTo(_ other: State) -> Bool
}

您的具体状态类型必须实现 isEqualTo 并在测试相等性之前执行类型检查:

struct State1: State {
  var foo: String
  func isEqualTo(_ other: State) -> Bool {
    guard let state1 = other as? State1 else { return false }
    return self.foo == state1.foo
  }
}

现在您可以将状态存储在数组中，例如检查是否已包含新状态:

let states: [State] = [ State1(foo: "hi"), State2(bar: 42), State1(foo: "bye")]
let newState = State2(bar: 42)
let containsNewState = states.contains { $0.isEqualTo(newState )}

关于ios - Swift:等同泛型数组，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/48401206/