比较枚举类型与关联值的值时的编译器错误？

问题描述

  class MyClass 
 {
 enum MyEnum {
 case FirstCase 
 case SecondCase（Int）
 case ThirdCase 
} 
 
 var state：MyEnum！ 
 
 func myMethod（）
 {
如果状态！ == MyEnum.FirstCase {
 //做某事
} 
} 
} 
  

如果二进制运算符'=='不能应用于两个'MyClass.MyEnum'
操作数

如果相反，我使用开关语句，没有问题：

 开关状态！ {
 //另外，为什么我需要```如果状态已经是
 //隐式展开的可选项？是否因为可选项
 //是内部枚举，编译器会感到困惑？ 
 
 case .FirstCase：
 //做某事... 
 
默认值：
 //（do nothing）
 break 
} 
  

但是，开关感觉太冗长了：我只想要为 .FirstCase 做一些，否则没有。一个如果语句更有意义。

枚举和 == ？

编辑：这是非常奇怪的。在定位开关版本后，转移到我的代码的其他（完全不相关）部分，然后回来， if -statement版本（针对固定枚举大小写的comnparing force-unwrapped属性）正在编译而没有错误。
我只能得出结论，它与解析器中被清理的一些损坏的缓存有关。

编辑2 其他枚举情况（不是我在比较的对象） - 在这种情况下，.SecondCase ）。我仍然不明白为什么特别会触发这个编译器错误（不能使用二进制运算符==...），或者这意味着什么。

解决方案

正如您在评论中所说，您的枚举类型实际上具有关联的
值。在这种情况下，枚举类型没有默认的 == 运算符。

但是您可以使用模式匹配甚至在如果语句（自Swift 2以来）：

  class MyClass { 
 enum MyEnum {
 case FirstCase 
 case SecondCase 
 case ThirdCase（Int）
} 
 
 var state：MyEnum！ 
 
 func myMethod（）{
 if case .FirstCase？ = state {
 
} 
} 
} 
  

这里 .FirstCase？是的快捷方式.Some（MyEnum.FirstCase）。

在switch语句中，状态不会自动解开，
即使它是一个隐式解包的可选（否则你可以
不符合 nil ）。但是在这里可以使用相同的模式：

  switch state {
 case .FirstCase ?: 
 / /做某事... 
默认值：
 break 
} 
  

class MyClass
{
    enum MyEnum {
        case FirstCase
        case SecondCase(Int)
        case ThirdCase
    }

    var state:MyEnum!

    func myMethod ()
    {
        if state! == MyEnum.FirstCase {
            // Do something
        }
    }
}

I get the compiler error pointing at the if statement::

If instead, I use a switch statement, there is no problem:

switch state! {
    // Also, why do I need `!` if state is already an
    // implicitly unwrapped optional? Is it because optionals also
    // are internally enums, and the compiler gets confused?

case .FirstCase:
    // do something...

default:
    // (do nothing)
    break
}

However, the switch statement feels too verbose: I just want to do something for .FirstCase, and nothing otherwise. An if statement makes more sense.

What's going on with enums and == ?

EDIT: This is ultra-weird. After settling for the switch version and moving on to other (totally unrelated) parts of my code, and coming back, the if-statement version (comnparing force-unwrapped property against fixed enum case) is compiling with no errors.I can only conclude that it has something to do with some corrupted cache in the parser that got cleared along the way.

EDIT 2 (Thanks @LeoDabus and @MartinR): It seems that the error appears when I set an associated value to the other enum case (not the one I am comparing against - in this case, .SecondCase). I still don't understand why that triggers this compiler error in particular ("Can't use binary operator '=='..."), or what that means.

解决方案

As you said in a comment, your enumeration type actually has associatedvalues. In that case there is no default == operator for the enum type.

But you can use pattern matching even in an if statement (since Swift 2):

class MyClass {
    enum MyEnum {
        case FirstCase
        case SecondCase
        case ThirdCase(Int)
    }

    var state:MyEnum!

    func myMethod () {
        if case .FirstCase? = state {

        }
    }
}

Here .FirstCase? is a shortcut for .Some(MyEnum.FirstCase).

In your switch-statement, state is not automatically unwrapped,even if it is an implicitly unwrapped optional (otherwise you couldnot match against nil). But the same pattern can be used here:

switch state {
case .FirstCase?:
    // do something...
default:
    break
}

这篇关于比较枚举类型与关联值的值时的编译器错误？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！