标签: equatable

我有以下枚举：

enum Message: ErrorType {
    case MessageWithInfo(info:String?)
    case MessageDidFail
    case MessageDidSend(info:String)
    case InvalidMessageData
    case MessageWithDelay(delay:Double)
    .... will keep adding more
}

我想弄清楚如何编写 Equatable 函数，然后让我比较 Message 枚举。

我发现了一些关于堆栈溢出的类似问题，但我找不到一个可以让我进行比较而不必打开每个案例的问题。

有没有办法编写一次 equatable 函数并让它工作，即使我不断向这个枚举添加更多案例？

包含方法不能正常工作,即使它与Object匹配,它也会给我错误的结果？

我的代码如下

class Generic: NSObject, NSCoding
{

  var genericCode: String?
  var genericName : String?
  var genericType : String?
  var genericImageUrl : String?
  var genericPhone: String?
  var orgName : String?

  override init()
  {

    self.genericCode = String("")
    self.genericName = String("")
    self.genericType = String("")
    self.genericImageUrl = String("")
    self.genericPhone = String("")
    self.orgName = String("")

  }

  //Parameterzed Constructor for the Generic
  init(genericCode: String , genericName: String , genericPhone: String, genericType: String, genericImageUrl : String)
  {
    self.genericCode = genericCode
    self.genericName = genericName
    self.genericType = genericType
    self.genericImageUrl …

我有一个Node二叉树类，如下所示：

class Node<T: Equatable> {
    let value: T
    let left: Node<T>?
    let right: Node<T>?

    init(value: T, left: Node<T>? = nil, right: Node<T>? = nil) {
        self.value = value
        self.left = left
        self.right = right
    }
}

这些值必须是相等的。

我可以这样测试公平性：

let a = Node(value: 8)
let b = Node(value: 7)

let c = a.value > b.value

效果很好，c: true

但是当我编写一个使用节点公平性的通用函数时，我收到错误：

func isBinaryTree<T>(node: Node<T>) -> Bool {
    if let leftNode = node.left {
        guard leftNode.value < node.value else {
            return false …

我需要NOT类中的任何 Equatable项目的容器（例如从故事板初始的 UI 类）。我需要这样Generic

var items: [Equatable]?

但它不起作用，Equatable需要Generic。不存在公共Equatable类的问题。

好的 - 转到通用！但如果我这样做

class Item<Value: Equatable>: Equatable {
   var value: Value
   init(_ value: Value) {
       self.value = value
   }
   //Equatable
   public static func ==(lhs: Item, rhs: Item) -> Bool {
       return (lhs.value == rhs.value)
   }
}

那么我将被迫在我的 nonGeneric-UI 类中指定类型。像这样

var items: [Item<WhatShouldBeHere?>]?

但是我们又遇到了不存在公共Equatable类的问题

All Equatable 容器的任何解决方案？

我正在快速学习并阅读了有关扩展中运算符重载的主题，其中包括：

extension StreetAddress: Equatable {
    static func == (lhs: StreetAddress, rhs: StreetAddress) -> Bool {
        return
            lhs.number == rhs.number &&
            lhs.street == rhs.street &&
            lhs.unit == rhs.unit
    }
}

但我怎么知道我需要采用 Equatable 呢？

我尝试删除该协议，并且该功能的工作原理相同。不会报告任何警告或错误。为什么？

我写了以下扩展名来删除我的数组中的重复项.

extension Array where Element : Equatable{

    func removeDups() -> [Element]{
        var result = [Element]()

        for element in self{
            if !result.contains(element){
                result.append(element)
            }
        }

        return result
    }
}

线性阵列

let linearArr = [1,2,2,3]
linearArr.removeDups() // [1,2,3] works well!

多维数组

let multiDimArr : [[Int]] = [[1,2,3], [1,2,3], [1,2 ,4]]
multiDimArr.removeDups() // Error!

类型[Int]不符合Equatable

我读到这里.答案说使用阵列比较==应该可行.它不能一直工作:

作品

if (["1", "2"] == ["1", "2"]){
    print("true")
}

不行

if ([1, 2] == [1, 2]){ // ERROR!
    print("true")
}

运算符'=='的模糊使用

这很特别.我可以比较数组的String …

在项目中，我们将类用于模型层，因此我必须编写如下代码：

// MARK: - Hashable
extension Player: Hashable {
    static func == (lhs: Player, rhs: Player) -> Bool {
        return lhs.hashValue == rhs.hashValue
    }

    func hash(into hasher: inout Hasher) {
        hasher.combine(self.name)
    }
}

可以以某种方式避免这种样板吗？默认情况下是否可以实现该Equatable比较.hashValue？谢谢。

我使用枚举如下：

enum Views: Equatable {
    case home
    case poules(pouleID: String?)
}

我必须将枚举变量设置为.homeor .poules。Poules 也可以有一个像这样的参数：router.currentView = .poules(pouleID: "TEST")。

但是，当我想测试变量是否为.homeor类型.poules（并且不想提取参数）时，出现以下错误：

if router.currentView == .poules { // <--- (Error: Member 'poules(pouleID:)' expects argument of type 'String')
    // Do something
}

我在这里做错了什么？我对其他枚举使用了相同的结构，并且没有遇到任何问题。

我试图在单元测试中比较 swift Type 值，并注意到 XCTAssertEqual 无法编译，而与 == 比较则可以正常编译。

XCTAssertEqual(MyStruct.self, MyStruct.self)--> 编译失败，并出现错误“全局函数 'XCTAssertEqual( : :_:file:line:)' 要求 'MyStruct.Type' 符合 'Equatable'”

XCTAssertTrue(MyStruct.self == MyStruct.self)--> 编译正常

我想了解这两个比较有什么区别。

您可以在下面的图像中看到我正在尝试扩展Collection协议以包含一个被调用的方法removingDuplicates,该方法应该完全按照它所说的去做.编译器显示的错误似乎与Equatable协议的定义直接相矛盾.这是一个错误还是我误解了什么？