Question

考虑这个枚举：

enum DataType {
    case One (data: Int)
    case Two (value: String)
}

Swift具有模式匹配功能，可将枚举与关联值进行比较，如下所示：

let var1 = DataType.One(data: 123)
let var2 = DataType.One(data: 456)

if case DataType.One(data: _) = var2 {
    print ("var2 is DataType.One")
}

如何将一个变量与一个枚举类型进行比较，而不是将两个变量的枚举类型进行比较？我看到了很多类似的问题，但是没有一个问题集中在您拥有的情况上两个变量。

我基本上想要的是：

if case var1 = var2 {
    print ("var1 is the same enum type as var2")
}

Answer 1

只需像下面一样确认Equatable

extension DataType: Equatable {
    static func == (lhs: DataType, rhs: DataType) -> Bool {
        switch (lhs, rhs) {
        case (.One, .Two), (.Two, .One):
            return false
        case (.One, .One), (.Two, .Two):
            return true
        }
    }
}

如果您不想实现Equatable，只需将内容移入实例方法：

extension DataType{
    func isSame(_ other: DataType) -> Bool {
        switch (self, other) {
        case (.One, .Two), (.Two, .One):
            return false
        case (.One, .One), (.Two, .Two):
            return true
        }
    }
}

使用：

let isTypeEqual = DataType.One(value: 1).isSame(DataType.One(value: 2))
print (isTypeEqual) // true

Answer 2

更新的方法：

我认为对此没有本地支持。但是，您可以通过定义自定义运算符来实现此目的（最好使用协议，但也可以直接执行此操作）。像这样：

protocol EnumTypeEquatable {
    static func ~=(lhs: Self, rhs: Self) -> Bool
}

extension DataType: EnumTypeEquatable {
    static func ~=(lhs: DataType, rhs: DataType) -> Bool {
        switch (lhs, rhs) {
        case (.one, .one), 
             (.two, .two): 
            return true
        default: 
            return false
        }
    }
}

然后像这样使用它：

let isTypeEqual = DataType.One(value: 1) ~= DataType.One(value: 2)
print (isTypeEqual) // true

旧方法：

protocol EnumTypeEquatable {
    var enumCaseIdentifier: String { get }
}

extension DataType: EnumTypeEquatable {
    var enumCaseIdentifier: String {
        switch self {
        case .one: return "ONE"
        case .two: return "TWO"
        }
    }
}

func ~=<T>(lhs: T, rhs: T) -> Bool where T: EnumTypeEquatable {
    return lhs.enumCaseIdentifier == rhs.enumCaseIdentifier
}

较早的版本取决于运行时，并且可能根据enumCaseIdentifier的默认String(describing: self)实现提供，不建议这样做。（因为String(describing: self)使用CustromStringConvertible协议，并且可以更改）

Answer 3

这对我有用：

enum DataType {
    case one (data: Int)
    case two (value: String)
}

protocol EnumTypeEquatable {
    static func sameType(lhs: Self, rhs: Self) -> Bool
}

extension DataType: EnumTypeEquatable {
    static func sameType(lhs: DataType, rhs: DataType) -> Bool {
        if let caseLhs = Mirror(reflecting: lhs).children.first?.label, let caseRhs = Mirror(reflecting: rhs).children.first?.label {
            return (caseLhs == caseRhs)
        } else { return false }
    }
}

let isTypeEqual = DataType.sameType(lhs: .one(data: 1), rhs: .one(data: 2))
print (isTypeEqual) // true

比较两个枚举变量，无论其关联值如何

3 个答案: