Question

考虑以下代码：

enum Type {
    case Foo(Int)
    case Bar(Int)

    var isBar: Bool {
        if case .Bar = self {
            return true
        } else {
            return false
        }
    }
}

总的来说。我想写这样的东西：

enum Type {
    case Foo(Int)
    case Bar(Int)

    var isBar: Bool {
        return case .Bar = self
    }
}

但是这样的构造似乎并不存在于Swift中，或者我找不到它。

由于每个案例都有与之相关的数据，因此我认为不可能以~=运营商（或任何其他帮助者）的方式实施这些数据。相当于上面的表达式。无论如何，if case语句对所有枚举都是免费的，并且不需要手动实现。

因此我的问题是：实现isBar的方式是否比我上面的更简洁/声明/清洁/惯用？或者，更直接地，有没有办法将if case 语句表示为Swift 表达式？

Answer 1

更新2： 另一个解决方法......创建一个var，仅根据案例返回Int，然后使用静态（或实例，我认为静态看起来更干净）方法来测试案例的等效性。它不会与Equatable发生冲突，您不必重载运算符（除非您想用静态方法替换静态方法），并且您也不必创建单独的var isFoo， var isBar等等。

我知道你用这个例子来提出一个更通用的问题（如何使用'if case'作为表达式？）但如果不可能，这可能是一个有效的解决方法。如果这对待“症状”而不是“问题”，我道歉

enum Something{
    case Foo(Int)
    case Bar(Int)

    static func sameCase(a: Something, b: Something) -> Bool {
        return a.caseValue == b.caseValue
    }

    var caseValue: Int {
        switch self {
        case .Foo(_):
            return 0
        case .Bar(_):
            return 1
        }
    }

    //if necessary
    var isBar: Bool {
        return Something.sameCase(self, b: Something.Bar(0))
    }
}

Something.sameCase(.Bar(0), b: .Foo(0)) // false
Something.sameCase(.Bar(1), b: .Foo(2)) // false
Something.sameCase(.Foo(0), b: .Foo(0)) // true
Something.sameCase(.Bar(1), b: .Bar(2)) // true


Something.Bar(0).isBar // true
Something.Bar(5).isBar // true
Something.Foo(5).isBar // false

更新1：

好的，所以这似乎有效。如果重载==运算符以忽略值并仅在两个枚举相同的情况下返回true，则可以在isFoo方法中传递任何值并仍然确定类型。

我假设您需要自定义此功能以适应相关值，但这似乎是朝着正确方向迈出的一步

enum Something {
    case Foo(Int)
    case Bar(Int)

    var isFoo: Bool {
        return self == .Foo(0) // number doesn't matter here... see below
    }
}

func ==(a: Something, b: Something) -> Bool {
    switch (a,b) {
    case (.Bar(_), .Bar(_)):
        return true
    case (.Foo(_), .Foo(_)):
        return true
    default:
        return false

    }
}

let oneFoo = Something.Foo(1)
let twoFoo = Something.Foo(2)
let oneBar = Something.Bar(1)
let twoBar = Something.Bar(2)

oneFoo == twoFoo // true
oneFoo == oneFoo // true
oneFoo == oneBar // false
oneFoo == twoBar // false

<强> OLD：

您可以使用self和case名称直接检查它是哪种情况，您不必使用case关键字。希望这对您的情况有用：

enum Something{
    case Foo(Int)
    case Bar(Int)

    var isFoo: Bool {
        switch self {
        case Foo:
            return true
        case Bar:
            return false
        }
    }
}

Answer 2

我也有类似的疑问，我一直在寻找有关此问题的解决方法，并进入了此页面。我想出了这样的代码来妥协。

fileprivate enum TypePrimitive {
    case foo
    case bar
}

enum Type {
    case foo(Int)
    case bar(Int)
    fileprivate var primitiveType: TypePrimitive {
        switch self {
        case .foo(_): return .foo
        case .bar(_): return .bar
        }
    }
    var isFoo: Bool { self.primitiveType == .foo }
    var isBar: Bool { self.primitiveType == .bar }
}

我希望苹果公司可以通过添加一些Swift语言功能来提供更好的解决方案。

Answer 3

您在寻找?运营商吗？

三元条件运算符标题下的

documentation is here。

有没有办法将`if case`语句写成表达式？

3 个答案: