4

我有一Equatable堂课

class Item: Equatable {
    var value: AnyObject?
    var title: String
    init(title: String, value: AnyObject?) {
        self.title = title
        self.value = value
    }
    //Equatable
    public static func ==(lhs: Item, rhs: Item) -> Bool {
        return ((lhs.title == rhs.title) && (lhs.value === rhs.value))
    }  
}

但我想将 try varvalue转换为 Equatable，以便获得软等值结果

if let lValue = lhs.value as? Equatable,   // Error
   let rValue = rhs.value as? Equatable {  // Error
    valueEq = (lValue == rValue)
} else {
    valueEq = (lhs.value === rhs.value)
}

此代码捕获有关 Generic Equatable 的编译错误

我怎样才能为这门课做正确的 Equatable？

UPD

我想在我的故事板中使用我Item的UITableViewCellin。我无法创建通用UITableViewCell. 如果我尝试将 Item 作为Generic<T: Equatable>类，我将被迫在我的单元格中指定类型，

var items: [Item<OnlyThisHashableClass>]

但我想将 Item in Cells 用于任何对象

4

2 回答 2

4

简单的方法 - 类保持 NonGeneric，Generic only init，并在 GenericInit 创建 isEquals 方法

class FieldItem: CustomStringConvertible, Equatable {
    let value: Any?
    let title: String
    private let equals: (Any?) -> Bool
    init<Value: Equatable>(title: String, value: Value?) {
        func isEquals(_ other: Any?) -> Bool {
            if let l = value, let r = other {
                if let r = r as? Value {
                    return l == r
                } else {
                    return false
                }
            } else {
                return true
            }
        }
        self.title = title
        self.value = value
        self.equals = isEquals
    }
    //CustomStringConvertible
    var description: String { get { return title } }
    //Equatable
    public static func ==(lhs: FieldItem, rhs: FieldItem) -> Bool {
        return ((lhs.title == rhs.title) && lhs.equals(rhs.value))
    }

}
于 2017-09-18T22:11:15.760 回答
3

您不能AnyObject转换为Equatable.

您可以做的是定义Item为value, Wrapped, 必须是的泛型Equatable：

class Item<Wrapped: Equatable> {
    var title: String
    var value: Wrapped

    init(title: String, value: Wrapped) {
        self.title = title
        self.value = value
    }
}

extension Item: Equatable {
    static func ==(lhs: Item, rhs: Item) -> Bool {
        return lhs.title == rhs.title && lhs.value == rhs.value
    }
}

并且，让我们假设您有一些类，Foo， (a) 是不相等的；(b) 是你想用 包裹的东西Item；(c) 你真的想在恒等运算符的基础上将它们定义为等价的===。（我承认，我发现你称之为“软平等”的概念相当令人不安，但我不会在这里讨论。）

无论如何，您可以Foo根据身份运算符使您的类等价：

extension Foo: Equatable {
    static func ==(lhs: Foo, rhs: Foo) -> Bool {
        return lhs === rhs
    }
}

或者，如果您需要为许多类执行此操作，您甚至可以有一个用于这种身份平等的协议，然后您的非等价类可以符合以下要求：

protocol IdentityEquatable: class, Equatable { }

extension IdentityEquatable {
    static func ==(lhs: Self, rhs: Self) -> Bool {
        return lhs === rhs
    }
}

然后，您想要包装的任何类Item都Equatable可以采用这种身份平等行为，每个类都只需一行代码：

extension Foo: IdentityEquatable { }
extension Bar: IdentityEquatable { }
extension Baz: IdentityEquatable { }

顺便说一句，SE-0143已经获得批准，虽然还不是语言的一部分，但它在未来的 Swift 版本中提供了条件一致性的承诺，即：

class Item<Wrapped> {
    var title: String
    var value: Wrapped

    init(title: String, value: Wrapped) {
        self.title = title
        self.value = value
    }
}

extension Item: Equatable where Wrapped: Equatable {
    static func ==(lhs: Item, rhs: Item) -> Bool {
        return lhs.title == rhs.title && lhs.value == rhs.value
    }
}

在这种情况下，Item当Equatable且仅当Wrapped值为Equatable. 这还不是语言的一部分，但看起来它将在未来的版本中。这是解决这个问题的一个优雅的解决方案（虽然不是，诚然，你的“软平等”想法）。

于 2017-09-01T06:46:04.223 回答