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） - ＆gt; SlideTemplate'”

我不知道如何解决这个问题。我查找了比较枚举的其他案例，但我无法将这些应用于这种情况。

Answer 1

主要想法是在需要时比较相关值和raw值。所以，你== func可以是这样的：

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
    }
}

例如，如果您不需要比较raw的{{1}}值，则只能检查相关值：

.centered

正如@ user28434所述，您应该... case (.centered, .centered): return true ...符合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进行比较。

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")
    }
}

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
            }
        }
    }
}

将枚举与参数进行比较

3 个答案: