如何检查Swift嵌套枚举是否仅与外部枚举相等？

我试图使用嵌套枚举来描述我的模型，这种方式使非法状态变得不可能，并在顶层提供分类。现在，我的（简化）代码是：

---

使用

if case…

和通配符感觉应该很简单，但我不知道如何实现这一点。我希望没有必要使用一个巨大的switch语句，因为我的实际模型更复杂。

我认为您需要一个switch语句，用一个“复合case”列出所有 外部枚举的可能“相同值组合”， 加上默认情况：

func isSameCategory(as other: SportsEvent) -> Bool {
    switch (self, other) {
    case (.running, .running),
         (.throwing, .throwing):
        return true
    default:
        return false
    }
}

或者（归属于@Hamish）：

它的优点是编译器会检查是否涵盖了所有情况。对于具有使

2*n

---

switch语句中的案例（如果您选中了所有可能的组合，则比

n*n

更好）。

根据您的用例，您可能能够将

SportEvent

转换为协议：

enum RunningEvent {
    case sprint
    case marathon
}

enum ThrowingEvent {
    case hammer
    case javelin
    case discus
}

enum SportEventCategory {
    case running
    case throwing
}

protocol SportEvent {
    var category: SportEventCategory { get }
}

extension RunningEvent: SportEvent {
    var category: SportEventCategory {
        return .running
    }
}

extension ThrowingEvent: SportEvent {
    var category: SportEventCategory {
        return .throwing
    }
}

let sportEvent1: SportEvent = RunningEvent.sprint
let sportEvent2: SportEvent = ThrowingEvent.hammer
print(sportEvent1.category == sportEvent2.category)

甚至作为一个平面枚举：

enum SportEvent {
    enum Category {
        case running
        case throwing
    }

    case sprint
    case marathon
    case hammer
    case javelin
    case discus

    var category: Category {
        switch self {
        case .sprint, .marathon, .hammer:
            return .running
        case .javelin, .discus:
            return .throwing
        }
    }
}

let sportEvent1: SportEvent = .sprint
let sportEvent2: SportEvent = .marathon
print(sportEvent1.category == sportEvent2.category)

---

看起来不错，并且没有太大的维护问题，因为外部值集可能相当/非常稳定。请注意，如果希望编译器确保涵盖所有情况，可以使用类似于

case（.running，u），（.throwing，u）：return false的内容替换
default
。这是更多的重复，但你得到额外的保证，所有案件都涵盖在内。希望Swift的未来版本将使使用带有关联值的枚举变得更容易–但目前的情况并不理想。@Hamish:这就是我一直在努力解决的问题–谢谢！一个有趣的选择，谢谢。我需要对它（在实际用例中）进行更多的思考。@Chris有很多可能性。对于运行和抛出事件，您也可以只有一个枚举，只需为所有事件添加一个
var类别。有很多方法可以做到这一点，但很难找到最好的方法。是的，的确如此。最终，我将使用外部类别进行分组（类似于
[（类别：SportEventCategory，events:[Event]）]
，供UITableViewDataSource使用），因此我需要选择一种适合的方法。最初的纯枚举版本不是很适合。我将尝试应用平坦枚举方法。
enum RunningEvent {
    case sprint
    case marathon
}

enum ThrowingEvent {
    case hammer
    case javelin
    case discus
}

enum SportEventCategory {
    case running
    case throwing
}

protocol SportEvent {
    var category: SportEventCategory { get }
}

extension RunningEvent: SportEvent {
    var category: SportEventCategory {
        return .running
    }
}

extension ThrowingEvent: SportEvent {
    var category: SportEventCategory {
        return .throwing
    }
}

let sportEvent1: SportEvent = RunningEvent.sprint
let sportEvent2: SportEvent = ThrowingEvent.hammer
print(sportEvent1.category == sportEvent2.category)

enum SportEvent {
    enum Category {
        case running
        case throwing
    }

    case sprint
    case marathon
    case hammer
    case javelin
    case discus

    var category: Category {
        switch self {
        case .sprint, .marathon, .hammer:
            return .running
        case .javelin, .discus:
            return .throwing
        }
    }
}

let sportEvent1: SportEvent = .sprint
let sportEvent2: SportEvent = .marathon
print(sportEvent1.category == sportEvent2.category)