比较带参数的枚举类型

Question

下面是我拥有的一些枚举：

enum SlideTemplate : Equatable {
    case centered(content: SlideContent)
    case horizontalSplit(leftContent: SlideContent, rightContent: SlideContent)
    case empty

    static func == (lhs: SlideTemplate, rhs: SlideTemplate) -> Bool {
        // not sure what to do here
    }
}

enum SlideContent {
    case text(content: String)
    case image(content: UIImage)
}

struct Slide {
    let template: SlideTemplate
}

现在我想检查幻灯片使用的模板类型。

func getSlideTemplate(slide: Slide) {
    if slide.template == SlideTemplate.centered {
        print("centered")
    } else if slide.template == SlideTemplate.horizontalSplit {
        print("horizontalSplit")
    } else {
        print("empty")
    }
}

上面的函数显然不起作用。它声明：

“二元运算符'=='不能应用于类型为'SlideTemplate'和'(SlideContent, SlideContent)->SlideTemplate'的操作数”。

我不确定如何解决这个问题。我查了其他比较枚举的情况，但是我无法将它们应用到这个情况中。

- Human Cyborg Relations

Answer 1

本文主要讲述了比较相关值和需要的原始值。因此，您的==函数可以像这样：

static func == (lhs: SlideTemplate, rhs: SlideTemplate) -> Bool {
    switch (lhs, rhs) {
    case let (.centered(lvalue), .centered(rvalue)):
        return lvalue == rvalue
    case let (.horizontalSplit(lleft, lright), .horizontalSplit(rleft, rright)):
        return lleft == rleft && lright == rright
    case (.empty, .empty):
        return true
    default:
        return false
    }
}

例如，如果您不需要比较 .centered 的 raw 值，您可以仅检查相关值：

...
case (.centered, .centered):
    return true
...

正如@user28434所提到的，您还应该使SlideContent符合Equatable协议。

static func ==(lhs: SlideContent, rhs: SlideContent) -> Bool {
    switch (lhs, rhs) {
    case let (.text(lcontent), .text(rcontent)):
        return lcontent == rcontent
    case let (.image(lcontent), .image(rcontent)):
        return lcontent == rcontent
    default:
        return false
    }
}

现在，你可以使用==进行完整类型值的比较，例如：

if slide.template == SlideTemplate.centered(content: SlideContent.text(content: "SomeContent")) {
    print("centered for SomeContent")
}

为了快速比较相关的值，您可以使用if case结构：

if case .centered = slide.template {
    print("centered")
}

---

结论.

• 如果你想知道 "哪种类型的SlideTemplate包含了这个属性" - 使用 if case .centered = slide.template { ... } 的方式而不需要实现 Equatable 协议。
• 如果您想完全比较 SlideTemplate 属性 - 实现 Equatable 协议并使用 == 进行比较。

- pacification

---

注意：SlideContent也应该是可比较的（Equatable），以便进行完整比较（第一个代码段）。 - user28434'mstep

@pacification 我已经实现了这个。然而，我原来问题中的函数仍然给我同样的错误。 - Human Cyborg Relations

Answer 2

如果你只需要在getSlideTemplate中检查枚举值，实际上根本不需要使用==。只需使用if case：

func getSlideTemplate(slide: Slide) {
    if case SlideTemplate.centered = slide.template {
        print("centered")
    } else if case SlideTemplate.horizontalSplit = slide.template {
        print("horizontalSplit")
    } else {
        print("empty")
    }
}

或者，更好的选择是 switch:

func getSlideTemplate(slide: Slide) {
    switch slide.template {
    case .centered:
        print("centered")
    case .horizontalSplit:
        print("horizontalSplit")
    case .empty:
        print("empty")
    }
}

- user28434'mstep

Answer 3

如果您也比较内容，这可能适用于您

enum SlideTemplate : Equatable {
    case centered(content: SlideContent)
    case horizontalSplit(leftContent: SlideContent, rightContent: SlideContent)
    case empty

    static func == (lhs: SlideTemplate, rhs: SlideTemplate) -> Bool {
        // not sure what to do here

        switch  lhs {
        case .centered(let content):
            switch rhs {
            case .centered(content: let rhsContent):
                return content == rhsContent
            default:
                return false
            }
        case .horizontalSplit(let leftContent, let rightContent):
            switch rhs {
            case .horizontalSplit(let rhsLeftContent, let rhsRightContent):
                return leftContent == rhsLeftContent && rightContent == rhsRightContent
            default:
                return false
            }
        case .empty:
            switch rhs {
            case .empty:
                return true
            default:
                return false
            }
        }
    }
}

enum SlideContent: Equatable {

    case text(content: String)
    case image(content: UIImage)

    static func ==(lhs: SlideContent, rhs: SlideContent) -> Bool {
        switch lhs {
        case .text(let content):
            switch  rhs {
            case .text(let rhsContent):
                return content == rhsContent
            default:
                return false
            }
        case .image(let content):
            switch rhs {
            case .image(let rhsContent):
                return content == rhsContent
            default:
                return false
            }
        }
    }
}

- Abhijit