blocks|key|4607556|text|t1和t2不是数字，它们是具有关联的值的SimpleTokens的实例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4607557|你可以说|4607558|var+t1+=+SimpleToken.Number(123)|code-block|syntax|javascript|4607559|然后你可以说|4607560|t1+=+SimpleToken.Name(“Smith”)+|4607561|没有编译器错误。|4607562|要从t1检索值，请使用switch语句：|4607563|switch+t1+{
++++case+let+.Number(numValue):
++++++++println("Number:+\(numValue)")
++++case+let+.Name(strValue):
++++++++println("Name:+\(strValue)")
}|4607564|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|11|8|@]|9|@]|A|$G|H]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

t1 and t2 are not numbers, they are instances of SimpleTokens with values associated.

You can say

<pre><code>var t1 = SimpleToken.Number(123)
</code></pre>

You can then say 

<pre><code>t1 = SimpleToken.Name(“Smith”) 
</code></pre>

without a compiler error.

To retrieve the value from t1, use a switch statement:

<pre><code>switch t1 {
 case let .Number(numValue):
 println("Number: \(numValue)")
 case let .Name(strValue):
 println("Name: \(strValue)")
}
</code></pre>

blocks|key|101052|text|您可以使用switch进行比较|type|unstyled|depth|inlineStyleRanges|entityRanges|data|101053|enum+SimpleToken+{
++++case+Name(String)
++++case+Number(Int)
}

let+t1+=+SimpleToken.Number(123)
let+t2+=+SimpleToken.Number(123)

switch(t1)+{

case+let+.Number(a):
++++switch(t2)+{
++++++++case+let+.+Number(b):
++++++++++++if+a+==+b
++++++++++++{
++++++++++++++++println("Equal")
++++++++}
++++++++default:
++++++++++++println("Not+equal")
++++}
default:
++++println("No+Match")
}|code-block|syntax|javascript|101054|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can compare using switch

<pre><code>enum SimpleToken {
 case Name(String)
 case Number(Int)
}

let t1 = SimpleToken.Number(123)
let t2 = SimpleToken.Number(123)

switch(t1) {

case let .Number(a):
 switch(t2) {
 case let . Number(b):
 if a == b
 {
 println("Equal")
 }
 default:
 println("Not equal")
 }
default:
 println("No Match")
}
</code></pre>

blocks|key|4607668|text|Swift+4.1%2B|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4607669|正如@jedwidz所指出的，从Swift+4.1+(由于SE-0185，Swift还支持为具有关联值的枚举合成Equatable和Hashable。|offset|length|style|CODE|4607670|因此，如果你使用的是Swift+4.1或更高版本，下面的代码将自动合成必要的方法，使XCTAssert(t1+==+t2)正常工作。关键是将Equatable协议添加到您的枚举。|4607671|enum+SimpleToken:+Equatable+{
++++case+Name(String)
++++case+Number(Int)
}
let+t1+=+SimpleToken.Number(123)
let+t2+=+SimpleToken.Number(123)|code-block|syntax|javascript|4607672|在Swift+4.1之前|4607673|正如其他人所指出的，Swift不会自动合成必要的相等运算符。不过，让我提出一个更干净的(IMHO)实现：|4607674|enum+SimpleToken:+Equatable+{
++++case+Name(String)
++++case+Number(Int)
}

public+func+==(lhs:+SimpleToken,+rhs:+SimpleToken)+->+Bool+{
++++switch+(lhs,+rhs)+{
++++case+let+(.Name(a),+++.Name(b)),
+++++++++let+(.Number(a),+.Number(b)):
++++++return+a+==+b
++++default:
++++++return+false
++++}
}|4607675|这并不理想-有很多重复-但至少你不需要在if语句中做嵌套开关。|4607676|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/2396171/jedwidz|1|https://github.com/apple/swift-evolution/blob/master/proposals/0185-synthesize-equatable-hashable.md^0|0|1K|9|1U|8|2|8|0|T|7|1|0|16|J|1Y|9|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@$D|18|E|19|F|G]|$D|1A|E|1B|F|G]]|9|@$D|1C|E|1D|1|1E]|$D|1F|E|1G|1|1H]]|A|$]]|$1|H|3|I|5|6|7|1I|8|@$D|1J|E|1K|F|G]|$D|1L|E|1M|F|G]]|9|@]|A|$]]|$1|J|3|K|5|L|7|1N|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1O|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1P|8|@]|9|@]|A|$]]|$1|S|3|T|5|L|7|1Q|8|@]|9|@]|A|$M|N]]|$1|U|3|V|5|6|7|1R|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]|14|$5|Z|10|11|A|$12|15]]]]

<h1>Swift 4.1+</h1>

As <a href="https://stackoverflow.com/users/2396171/jedwidz">@jedwidz</a> has helpfully pointed out, from Swift 4.1 (due to <a href="https://github.com/apple/swift-evolution/blob/master/proposals/0185-synthesize-equatable-hashable.md" rel="noreferrer">SE-0185</a>, Swift also supports synthesizing <code>Equatable</code> and <code>Hashable</code> for enums with associated values.

So if you're on Swift 4.1 or newer, the following will automatically synthesize the necessary methods such that <code>XCTAssert(t1 == t2)</code> works. The key is to add the <code>Equatable</code> protocol to your enum.

<pre class="lang-swift prettyprint-override"><code>enum SimpleToken: Equatable {
 case Name(String)
 case Number(Int)
}
let t1 = SimpleToken.Number(123)
let t2 = SimpleToken.Number(123)
</code></pre>

<h1>Before Swift 4.1</h1>

As others have noted, Swift doesn't synthesize the necessary equality operators automatically. Let me propose a cleaner (IMHO) implementation, though:

<pre class="lang-swift prettyprint-override"><code>enum SimpleToken: Equatable {
 case Name(String)
 case Number(Int)
}

public func ==(lhs: SimpleToken, rhs: SimpleToken) -&gt; Bool {
 switch (lhs, rhs) {
 case let (.Name(a), .Name(b)),
 let (.Number(a), .Number(b)):
 return a == b
 default:
 return false
 }
}
</code></pre>

It's far from ideal — there's a lot of repetition — but at least you don't need to do nested switches with if-statements inside.

blocks|key|4607727|text|我在单元测试代码中使用了这个简单的解决方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4607728|extension+SimpleToken:+Equatable+{}
func+==(lhs:+SimpleToken,+rhs:+SimpleToken)+->+Bool+{
++++return+String(stringInterpolationSegment:+lhs)+==+String(stringInterpolationSegment:+rhs)
}|code-block|syntax|javascript|4607729|它使用字符串插值来执行比较。我不推荐将其用于生产代码，但它非常简洁，并且可以完成单元测试的工作。|4607730|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I'm using this simple workaround in unit test code:

<pre><code>extension SimpleToken: Equatable {}
func ==(lhs: SimpleToken, rhs: SimpleToken) -&gt; Bool {
 return String(stringInterpolationSegment: lhs) == String(stringInterpolationSegment: rhs)
}
</code></pre>

It uses string interpolation to perform the comparison. I would not recommend it for production code, but it's concise and does the job for unit testing.

blocks|key|101173|text|与被接受的答案相比，“优势”在于，“main”switch语句中没有“default”case，因此如果您使用其他case扩展枚举，编译器将强制您更新其余代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|101174|enum+SimpleToken:+Equatable+{
++++case+Name(String)
++++case+Number(Int)
}
extension+SimpleToken+{
++++func+isEqual(st:+SimpleToken)->Bool+{
++++++++switch+self+{
++++++++case+.Name(let+v1):
++++++++++++switch+st+{
++++++++++++case+.Name(let+v2):+return+v1+==+v2
++++++++++++default:+return+false
++++++++++++}
++++++++case+.Number(let+i1):
++++++++++++switch+st+{
++++++++++++case+.Number(let+i2):+return+i1+==+i2
++++++++++++default:+return+false
++++++++++++}
++++++++}
++++}
}


func+==(lhs:+SimpleToken,+rhs:+SimpleToken)->Bool+{
++++return+lhs.isEqual(rhs)
}

let+t1+=+SimpleToken.Number(1)
let+t2+=+SimpleToken.Number(2)
let+t3+=+SimpleToken.Name("a")
let+t4+=+SimpleToken.Name("b")

t1+==+t1++//+true
t1+==+t2++//+false
t3+==+t3++//+true
t3+==+t4++//+false
t1+==+t3++//+false|code-block|syntax|javascript|101175|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

the 'advantage' when compare to accepted answer is, that there is no 'default' case in 'main' switch statement, so if you extend your enum with other cases, the compiler will force you to update the rest of code.

<pre><code>enum SimpleToken: Equatable {
 case Name(String)
 case Number(Int)
}
extension SimpleToken {
 func isEqual(st: SimpleToken)-&gt;Bool {
 switch self {
 case .Name(let v1):
 switch st {
 case .Name(let v2): return v1 == v2
 default: return false
 }
 case .Number(let i1):
 switch st {
 case .Number(let i2): return i1 == i2
 default: return false
 }
 }
 }
}


func ==(lhs: SimpleToken, rhs: SimpleToken)-&gt;Bool {
 return lhs.isEqual(rhs)
}

let t1 = SimpleToken.Number(1)
let t2 = SimpleToken.Number(2)
let t3 = SimpleToken.Name("a")
let t4 = SimpleToken.Name("b")

t1 == t1 // true
t1 == t2 // false
t3 == t3 // true
t3 == t4 // false
t1 == t3 // false
</code></pre>

blocks|key|4607787|text|这里有另一个选择。除了通过使用if+case语法避免了嵌套的switch语句之外，它与其他方法基本相同。我认为这使得它更具可读性(/bearable)，并且具有完全避免缺省情况的优点。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4607788|enum+SimpleToken:+Equatable+{
++++case+Name(String)
++++case+Number(Int)
}
extension+SimpleToken+{
++++func+isEqual(st:+SimpleToken)->Bool+{
++++++++switch+self+{
++++++++case+.Name(let+v1):+
++++++++++++if+case+.Name(let+v2)+=+st+where+v1+==+v2+{+return+true+}
++++++++case+.Number(let+i1):+
++++++++++++if+case+.Number(let+i2)+=+st+where+i1+==+i2+{+return+true+}
++++++++}
++++++++return+false
++++}
}

func+==(lhs:+SimpleToken,+rhs:+SimpleToken)->Bool+{
++++return+lhs.isEqual(rhs)
}

let+t1+=+SimpleToken.Number(1)
let+t2+=+SimpleToken.Number(2)
let+t3+=+SimpleToken.Name("a")
let+t4+=+SimpleToken.Name("b")

t1+==+t1++//+true
t1+==+t2++//+false
t3+==+t3++//+true
t3+==+t4++//+false
t1+==+t3++//+false|code-block|syntax|javascript|4607789|entityMap^0|F|7|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Here's another option. It's mainly the same as the others except it avoids the nested switch statements by using the <code>if case</code> syntax. I think this makes it slightly more readable(/bearable) and has the advantage of avoiding the default case altogether.

<pre><code>enum SimpleToken: Equatable {
 case Name(String)
 case Number(Int)
}
extension SimpleToken {
 func isEqual(st: SimpleToken)-&gt;Bool {
 switch self {
 case .Name(let v1): 
 if case .Name(let v2) = st where v1 == v2 { return true }
 case .Number(let i1): 
 if case .Number(let i2) = st where i1 == i2 { return true }
 }
 return false
 }
}

func ==(lhs: SimpleToken, rhs: SimpleToken)-&gt;Bool {
 return lhs.isEqual(rhs)
}

let t1 = SimpleToken.Number(1)
let t2 = SimpleToken.Number(2)
let t3 = SimpleToken.Name("a")
let t4 = SimpleToken.Name("b")

t1 == t1 // true
t1 == t2 // false
t3 == t3 // true
t3 == t4 // false
t1 == t3 // false
</code></pre>

blocks|key|4607807|text|enum+MyEnum+{
++++case+none
++++case+simple(text:+String)
++++case+advanced(x:+Int,+y:+Int)
}

func+==(lhs:+MyEnum,+rhs:+MyEnum)+->+Bool+{
++++switch+(lhs,+rhs)+{
++++case+(.none,+.none):
++++++++return+true
++++case+let+(.simple(v0),+.simple(v1)):
++++++++return+v0+==+v1
++++case+let+(.advanced(x0,+y0),+.advanced(x1,+y1)):
++++++++return+x0+==+x1+&&+y0+==+y1
++++default:
++++++++return+false
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|4607808|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>enum MyEnum {
 case none
 case simple(text: String)
 case advanced(x: Int, y: Int)
}

func ==(lhs: MyEnum, rhs: MyEnum) -&gt; Bool {
 switch (lhs, rhs) {
 case (.none, .none):
 return true
 case let (.simple(v0), .simple(v1)):
 return v0 == v1
 case let (.advanced(x0, y0), .advanced(x1, y1)):
 return x0 == x1 &amp;&amp; y0 == y1
 default:
 return false
 }
}
</code></pre>

blocks|key|101233|text|另一个选择是比较大小写的字符串表示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|101234|XCTAssert(String(t1)+==+String(t2))|code-block|syntax|javascript|101235|例如：|101236|let+t1+=+SimpleToken.Number(123)+//+the+string+representation+is+"Number(123)"
let+t2+=+SimpleToken.Number(123)
let+t3+=+SimpleToken.Name("bob")+//+the+string+representation+is+"Name(\"bob\")"

String(t1)+==+String(t2)+//true
String(t1)+==+String(t3)+//false|101237|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Another option would be to compare the string representations of the cases:

<pre><code>XCTAssert(String(t1) == String(t2))
</code></pre>

For example:

<pre><code>let t1 = SimpleToken.Number(123) // the string representation is "Number(123)"
let t2 = SimpleToken.Number(123)
let t3 = SimpleToken.Name("bob") // the string representation is "Name(\"bob\")"

String(t1) == String(t2) //true
String(t1) == String(t3) //false
</code></pre>

blocks|key|101269|text|另一种使用带逗号的if+case的方法，在Swift+3中有效：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|101270|enum+{
++case+kindOne(String)
++case+kindTwo(NSManagedObjectID)
++case+kindThree(Int)

++static+func+==(lhs:+MyEnumType,+rhs:+MyEnumType)+->+Bool+{
++++if+case+.kindOne(let+l)+=+lhs,
++++++++case+.kindOne(let+r)+=+rhs+{
++++++++return+l+==+r
++++}
++++if+case+.kindTwo(let+l)+=+lhs,
++++++++case+.kindTwo(let+r)+=+rhs+{
++++++++return+l+==+r
++++}
++++if+case+.kindThree(let+l)+=+lhs,
++++++++case+.kindThree(let+r)+=+rhs+{
++++++++return+l+==+r
++++}
++++return+false
++}
}|code-block|syntax|javascript|101271|这就是我在我的项目中写的。但是我不记得我是从哪里得到这个想法的。(我刚才谷歌了一下，没看到这样的用法。)如有任何意见，我们将不胜感激。|101272|entityMap^0|9|7|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

Another approach using <code>if case</code> with commas, which works in Swift 3:

<pre><code>enum {
 case kindOne(String)
 case kindTwo(NSManagedObjectID)
 case kindThree(Int)

 static func ==(lhs: MyEnumType, rhs: MyEnumType) -&gt; Bool {
 if case .kindOne(let l) = lhs,
 case .kindOne(let r) = rhs {
 return l == r
 }
 if case .kindTwo(let l) = lhs,
 case .kindTwo(let r) = rhs {
 return l == r
 }
 if case .kindThree(let l) = lhs,
 case .kindThree(let r) = rhs {
 return l == r
 }
 return false
 }
}
</code></pre>

This is how I wrote in my project. But I can't remember where I got the idea. (I googled just now but didn't see such usage.) Any comment would be appreciated.

blocks|key|4607913|text|实现Equatable是一种过度的杀伤力。假设你有一个复杂而庞大的枚举，它有很多种情况和很多不同的参数。这些参数也都必须实现Equatable。此外，谁说您在全有或全无的基础上比较枚举用例？如果您正在测试值，并且只存根了一个特定的枚举参数，该怎么办呢？我强烈建议使用简单的方法，比如：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4607914|if+case+.NotRecognized+=+error+{
++++//+Success
}+else+{
++++XCTFail("wrong+error")
}|code-block|syntax|javascript|4607915|..。或者在参数求值的情况下：|4607916|if+case+.Unauthorized401(_,+let+response,+_)+=+networkError+{
++++XCTAssertEqual(response.statusCode,+401)
}+else+{
++++XCTFail("Unauthorized401+was+expected")
}|4607917|在这里可以找到更详细的描述：https://mdcdeveloper.wordpress.com/2016/12/16/unit-testing-swift-enums/|4607918|entityMap|0|LINK|mutability|MUTABLE|url|https://mdcdeveloper.wordpress.com/2016/12/16/unit-testing-swift-enums/^0|2|9|1Q|9|0|0|0|0|E|1Z|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|14|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|16|8|@]|D|@$9|17|A|18|1|19]]|E|$]]|$1|Q|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

Implementing <code>Equatable</code> is an overkill IMHO. Imagine you have complicated and large enum with many cases and many different parameters. These parameters will all have to have <code>Equatable</code> implemented, too. Furthermore, who said you compare enum cases on all-or-nothing basis? How about if you are testing value and have stubbed only one particular enum parameter? I would strongly suggest simple approach, like:

<pre><code>if case .NotRecognized = error {
 // Success
} else {
 XCTFail("wrong error")
}
</code></pre>

... or in case of parameter evaluation:

<pre><code>if case .Unauthorized401(_, let response, _) = networkError {
 XCTAssertEqual(response.statusCode, 401)
} else {
 XCTFail("Unauthorized401 was expected")
}
</code></pre>

Find more elaborate description here: <a href="https://mdcdeveloper.wordpress.com/2016/12/16/unit-testing-swift-enums/" rel="noreferrer">https://mdcdeveloper.wordpress.com/2016/12/16/unit-testing-swift-enums/</a>

blocks|key|4607961|text|扩展了mbpro的答案，下面是我如何使用这种方法来检查带有一些边缘情况的关联值的快速枚举的等价性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4607962|当然，您可以执行switch语句，但有时只检查一行中的一个值是很好的。你可以这样做：|4607963|//+NOTE:+there's+only+1+equal+(`=`)+sign!+Not+the+2+(`==`)+that+you're+used+to+for+the+equality+operator
//+2nd+NOTE:+Your+variable+must+come+2nd+in+the+clause

if+case+.yourEnumCase(associatedValueIfNeeded)+=+yourEnumVariable+{
++//+success
}|code-block|syntax|javascript|4607964|如果要比较同一If子句中的两个条件，则需要使用逗号而不是&&运算符：|offset|length|style|CODE|4607965|if+someOtherCondition,+case+.yourEnumCase+=+yourEnumVariable+{
++//+success
}|4607966|entityMap^0|0|0|0|S|2|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@$K|W|L|X|M|N]]|9|@]|A|$]]|$1|O|3|P|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Expanding on mbpro's answer, here's how I used that approach to check for equality of swift enums with associated values with some edge cases.

Of course you can do a switch statement, but sometimes it's nice to just check for one value in one line. You can do it like so:

<pre><code>// NOTE: there's only 1 equal (`=`) sign! Not the 2 (`==`) that you're used to for the equality operator
// 2nd NOTE: Your variable must come 2nd in the clause

if case .yourEnumCase(associatedValueIfNeeded) = yourEnumVariable {
 // success
}
</code></pre>

If you want to compare 2 conditions in the same if clause, you need to use the comma instead of the <code>&amp;&amp;</code> operator:

<pre><code>if someOtherCondition, case .yourEnumCase = yourEnumVariable {
 // success
}
</code></pre>

blocks|key|4608010|text|在SWIFT4.1中，只需将Equatable协议添加到枚举并使用XCTAssert或XCTAssertEqual|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4608011|enum+SimpleToken+:+Equatable+{
++++case+Name(String)
++++case+Number(Int)
}
let+t1+=+SimpleToken.Number(123)
let+t2+=+SimpleToken.Number(123)
XCTAssertEqual(t1,+t2)+//+OK|code-block|syntax|javascript|4608012|entityMap^0|E|9|X|9|17|E|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|L|$]]

From Swift 4.1 just add <code>Equatable</code> protocol to your enum and use <code>XCTAssert</code> or <code>XCTAssertEqual</code>:

<pre><code>enum SimpleToken : Equatable {
 case Name(String)
 case Number(Int)
}
let t1 = SimpleToken.Number(123)
let t2 = SimpleToken.Number(123)
XCTAssertEqual(t1, t2) // OK
</code></pre>

I want to test the equality of two Swift enum values. For example:

<pre><code>enum SimpleToken {
 case Name(String)
 case Number(Int)
}
let t1 = SimpleToken.Number(123)
let t2 = SimpleToken.Number(123)
XCTAssert(t1 == t2)
</code></pre>

However, the compiler won't compile the equality expression:

<pre><code>error: could not find an overload for '==' that accepts the supplied arguments
 XCTAssert(t1 == t2)
 ^~~~~~~~~~~~~~~~~~~
</code></pre>

Do I have do define my own overload of the equality operator? I was hoping the Swift compiler would handle it automatically, much like Scala and Ocaml do.

How to test equality of Swift enums with associated values

单元测试

编译器

Swift

我想测试两个Swift枚举值是否相等。例如：enum SimpleToken {    case Name(String)    case Number(Int)}let t1 = SimpleToken.Number(123)let t2 = SimpleToken.Number(123)XCTAssert(t1 =...

问如何测试Swift枚举与关联值的相等性
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何测试Swift枚举与关联值的相等性EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何测试Swift枚举与关联值的相等性
EN