swift - 在 Swift 4.2 中，如何编写 func<() 来比较类中的 3 个字段？

Question

这是一个包含 3 个字段的简单 Swift 类:

public class Cabbage: Comparable {
    public let someString: String
    public let someInt: Int
    public let someDouble: Double

    public init(_ someString: String, _ someInt: Int, _ someDouble: Double) {
        self.someString = someString
        self.someInt = someInt
        self.someDouble = someDouble
    }

    public static func ==(lhs: Cabbage, rhs: Cabbage) -> Bool {
        if lhs.someString == rhs.someString {
            if lhs.someInt == rhs.someInt {
                if lhs.someDouble == rhs.someDouble {
                    return true
                }
            }
        }
        return false
    }

    public static func <(lhs: Cabbage, rhs: Cabbage) -> Bool {
        if lhs.someString < rhs.someString {
            if lhs.someInt < rhs.someInt {
                if lhs.someDouble < rhs.someDouble {
                    return true
                }
            }
        }
        return false
    }
}

我认为我的第一个函数 func ==() 是正确的。当且仅当所有字段都相等时，我们才返回 true。

但我认为我的逻辑对于 func <() 是不正确的。

例如，如果 lhs.someString == rhs.someString，我是否应该比较 lhs.someInt 和 rhs.someInt？

如果这两者相等，我还应该比较 lhs.someDouble 和 rhs.someDouble 吗？

如有任何想法或建议，我们将不胜感激。

Answer 1

是的，仅仅检查 lhs.someString < rhs.someString 是不够的.您还需要确定是否 lhs.someString > rhs.someString (或者如果 lhs.someString == rhs.someString )。

正确书写的方法有很多种。这是一个:

public static func <(lhs: Cabbage, rhs: Cabbage) -> Bool {
    if lhs.someString < rhs.someString { return true }
    if rhs.someString < lhs.someString { return false }
    if lhs.someInt < rhs.someInt { return true }
    if rhs.someInt < lhs.someInt { return false }
    return lhs.someDouble < rhs.someDouble
}

更新

从 Swift 2.2 开始，标准库为最多六个元素的元组提供了比较运算符(如果所有元素都是 Comparable )。

此外，感谢 SE-0283 , 所有 元组将很快(可能在 Swift 5.3 之后出现)符合 Comparable (如果它们的元素都符合 Comparable )。

下面是 SE-0283 定义元组比较的方式:

Comparing a tuple to a tuple works elementwise:

Look at the first element, if they are equal move to the second element. Repeat until we find elements that are not equal and compare them.

此定义也适用于 Swift 2.2 中添加的现有元组比较运算符。它也称为词典顺序。

所以我们可以使用元组比较来编写一个较短版本的<对于 Cabbage :

extension Cabbage: Comparable {
    public static func <(lhs: Cabbage, rhs: Cabbage) -> Bool {
        return (lhs.someString, lhs.someInt, lhs.someDouble)
            < (rhs.someString, rhs.someInt, rhs.someDouble)
    }
}

我们可以通过提取比较键的计算属性来减少代码重复。那么我们也可以用它来定义==运算符(operator)。这就是我的意思:

extension Cabbage: Equatable, Comparable {
    var comparisonKey: (String, Int, Double) {
        return (someString, someInt, someDouble)
    }

    public static func ==(lhs: Cabbage, rhs: Cabbage) -> Bool {
        return lhs.comparisonKey == rhs.comparisonKey 
    }

    public static func <(lhs: Cabbage, rhs: Cabbage) -> Bool {
       return lhs.comparisonKey < rhs.comparisonKey
    }
}