Question

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

enum SportsEvent {

    enum RunningEvent {
        case sprint
        case marathon
    }

    enum ThrowingEvent {
        case hammer
        case javelin
        case discus
    }

    case running(event: RunningEvent)
    case throwing(event: ThrowingEvent)

    func isSameCategory(as other: SportsEvent) -> Bool {

        return false
    }
}

let sprint = SportsEvent.running(event: .sprint)
let javelin = SportsEvent.throwing(event: .javelin)
let hammer = SportsEvent.throwing(event: .hammer)

sprint.isSameCategory(as: javelin)      // False
hammer.isSameCategory(as: javelin)      // True

使用if case ...和通配符感觉应该是微不足道的，但我还没有看到如何实现这一目标。我希望一个巨大的转换声明是不必要的，因为我的实际模型更复杂。

Answer 1

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

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

或（归属于@Hamish）：

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

的优点是编译器会检查是否涵盖了所有案例。对于包含n个案2 * n n * n的枚举 switch语句中的case（如果检查了所有可能的组合，则优于{{1}}。）

Answer 2

根据您的使用情况，您可以将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)

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

2 个答案: