blocks|key|4554477|text|我有更详细的a+blog+post，但是只要你的枚举的原始类型是一个整数，你就可以这样添加一个计数：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4554478|enum+Reindeer:+Int+{
++++case+Dasher,+Dancer,+Prancer,+Vixen,+Comet,+Cupid,+Donner,+Blitzen
++++case+Rudolph

++++static+let+count:+Int+=+{
++++++++var+max:+Int+=+0
++++++++while+let+_+=+Reindeer(rawValue:+max)+{+max+%2B=+1+}
++++++++return+max
++++}()
}|code-block|syntax|javascript|4554479|entityMap|0|LINK|mutability|MUTABLE|url|http://natecook.com/blog/2014/10/loopy-random-enum-ideas/^0|6|B|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

I have <a href="http://natecook.com/blog/2014/10/loopy-random-enum-ideas/">a blog post</a> that goes into more detail on this, but as long as your enum's raw type is an integer, you can add a count this way:

<pre><code>enum Reindeer: Int {
 case Dasher, Dancer, Prancer, Vixen, Comet, Cupid, Donner, Blitzen
 case Rudolph

 static let count: Int = {
 var max: Int = 0
 while let _ = Reindeer(rawValue: max) { max += 1 }
 return max
 }()
}
</code></pre>

blocks|key|4554507|text|如果实现不反对使用整数枚举，您可以添加一个名为Count的额外成员值来表示枚举中的成员数量-请参见下面的示例：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4554508|enum+TableViewSections+:+Int+{
++case+Watchlist
++case+AddButton
++case+Count
}|code-block|syntax|javascript|4554509|现在，您可以通过调用TableViewSections.Count.rawValue来获取枚举中的成员数量，对于上面的示例，它将返回2。|4554510|在处理switch语句中的枚举时，请确保在遇到意外的Count成员时抛出断言失败：|4554511|func+tableView(tableView:+UITableView,+numberOfRowsInSection+section:+Int)+->+Int+{
++let+currentSection:+TableViewSections+=+TableViewSections.init(rawValue:section)!
++switch(currentSection)+{
++case+.Watchlist:
++++return+watchlist.count
++case+.AddButton:
++++return+1
++case+.Count:
++++assert(false,+"Invalid+table+view+section!")
++}
}|4554512|entityMap^0|N|5|0|0|A|W|0|Q|5|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|O|3|P|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|Q|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|R|$]]

If the implementation doesn't have anything against using integer enums, you could add an extra member value called <code>Count</code> to represent the number of members in the enum - see example below:

<pre><code>enum TableViewSections : Int {
 case Watchlist
 case AddButton
 case Count
}
</code></pre>

Now you can get the number of members in the enum by calling, <code>TableViewSections.Count.rawValue</code> which will return 2 for the example above. 

When you're handling the enum in a switch statement, make sure to throw an assertion failure when encountering the <code>Count</code> member where you don't expect it:

<pre><code>func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -&gt; Int {
 let currentSection: TableViewSections = TableViewSections.init(rawValue:section)!
 switch(currentSection) {
 case .Watchlist:
 return watchlist.count
 case .AddButton:
 return 1
 case .Count:
 assert(false, "Invalid table view section!")
 }
}
</code></pre>

blocks|key|47998|text|如果你不想把你的代码放在最后一个枚举中，你可以在你的枚举中创建这个函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|47999|func+getNumberOfItems()+->+Int+{
++++var+i:Int+=+0
++++var+exit:Bool+=+false
++++while+!exit+{
++++++++if+let+menuIndex+=+MenuIndex(rawValue:+i)+{
++++++++++++i%2B%2B
++++++++}else{
++++++++++++exit+=+true
++++++++}
++++}
++++return+i
}|code-block|syntax|javascript|48000|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|$]]

If you don't want to base your code in the last enum you can create this function inside your enum.

<pre><code>func getNumberOfItems() -&gt; Int {
 var i:Int = 0
 var exit:Bool = false
 while !exit {
 if let menuIndex = MenuIndex(rawValue: i) {
 i++
 }else{
 exit = true
 }
 }
 return i
}
</code></pre>

blocks|key|48057|text|我自己解决了这个问题，创建了一个协议(EnumIntArray)和一个全局实用函数(enumIntArray)，这使得向任何枚举添加"All“变量变得非常容易(使用Swift1.2)。all“变量将包含枚举中所有元素的数组，因此您可以使用all.count进行计数|type|unstyled|depth|inlineStyleRanges|entityRanges|data|48058|它只适用于使用Int类型的原始值的枚举，但也许它可以为其他类型提供一些启发。|48059|它还解决了我在上面和其他地方读到的“编号差距”和“迭代时间过长”问题。|48060|其思想是将EnumIntArray协议添加到枚举中，然后通过调用enumIntArray函数定义一个"all“静态变量，并为其提供第一个元素(如果编号中存在间隙，则为其提供最后一个元素)。|48061|因为静态变量只初始化一次，所以遍历所有原始值的开销只会影响程序一次。|48062|示例(无间隙)：|48063|enum+Animals:Int,+EnumIntArray
{+
++case+Cat=1,+Dog,+Rabbit,+Chicken,+Cow
++static+var+all+=+enumIntArray(Animals.Cat)
}|code-block|syntax|javascript|48064|示例(带间隙)：|48065|enum+Animals:Int,+EnumIntArray
{+
++case+Cat++++=+1,++Dog,+
++case+Rabbit+=+10,+Chicken,+Cow
++static+var+all+=+enumIntArray(Animals.Cat,+Animals.Cow)
}|48066|下面是实现它的代码：|48067|protocol+EnumIntArray
{
+++init?(rawValue:Int)
+++var+rawValue:Int+{+get+}
}

func+enumIntArray<T:EnumIntArray>(firstValue:T,+_+lastValue:T?+=+nil)+->+[T]
{
+++var+result:[T]+=+[]
+++var+rawValue+++=+firstValue.rawValue
+++while+true
+++{+
+++++if+let+enumValue+=+T(rawValue:rawValue%2B%2B)+
+++++{+result.append(enumValue)+}
+++++else+if+lastValue+==+nil+++++++++++++++++++++
+++++{+break+}

+++++if+lastValue+!=+nil
+++++&&+rawValue++>++lastValue!.rawValue++++++++++
+++++{+break+}
+++}+
+++return+result+++
}|48068|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|13|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|14|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|15|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|16|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|17|8|@]|9|@]|A|$]]|$1|S|3|T|5|N|7|18|8|@]|9|@]|A|$O|P]]|$1|U|3|V|5|6|7|19|8|@]|9|@]|A|$]]|$1|W|3|X|5|N|7|1A|8|@]|9|@]|A|$O|P]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

I solved this problem for myself by creating a protocol (EnumIntArray) and a global utility function (enumIntArray) that make it very easy to add an "All" variable to any enum (using swift 1.2). The "all" variable will contain an array of all elements in the enum so you can use all.count for the count

It only works with enums that use raw values of type Int but perhaps it can provide some inspiration for other types.

It also addresses the "gap in numbering" and "excessive time to iterate" issues I've read above and elsewhere.

The idea is to add the EnumIntArray protocol to your enum and then define an "all" static variable by calling the enumIntArray function and provide it with the first element (and the last if there are gaps in the numbering).

Because the static variable is only initialized once, the overhead of going through all raw values only hits your program once.

example (without gaps) :

<pre><code>enum Animals:Int, EnumIntArray
{ 
 case Cat=1, Dog, Rabbit, Chicken, Cow
 static var all = enumIntArray(Animals.Cat)
}
</code></pre>

example (with gaps) :

<pre><code>enum Animals:Int, EnumIntArray
{ 
 case Cat = 1, Dog, 
 case Rabbit = 10, Chicken, Cow
 static var all = enumIntArray(Animals.Cat, Animals.Cow)
}
</code></pre>

Here's the code that implements it:

<pre><code>protocol EnumIntArray
{
 init?(rawValue:Int)
 var rawValue:Int { get }
}

func enumIntArray&lt;T:EnumIntArray&gt;(firstValue:T, _ lastValue:T? = nil) -&gt; [T]
{
 var result:[T] = []
 var rawValue = firstValue.rawValue
 while true
 { 
 if let enumValue = T(rawValue:rawValue++) 
 { result.append(enumValue) }
 else if lastValue == nil 
 { break }

 if lastValue != nil
 &amp;&amp; rawValue &gt; lastValue!.rawValue 
 { break }
 } 
 return result 
}
</code></pre>

blocks|key|48093|text|我定义了一个可重用的协议，它根据Nate+Cook发布的方法自动执行案例计数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|48094|protocol+CaseCountable+{
++++static+var+caseCount:+Int+{+get+}
}

extension+CaseCountable+where+Self:+RawRepresentable,+Self.RawValue+==+Int+{
++++internal+static+var+caseCount:+Int+{
++++++++var+count+=+0
++++++++while+let+_+=+Self(rawValue:+count)+{
++++++++++++count+%2B=+1
++++++++}
++++++++return+count
++++}
}|code-block|syntax|javascript|48095|然后我可以像下面这样重用这个协议：|48096|enum+Planet+:+Int,+CaseCountable+{
++++case+Mercury,+Venus,+Earth,+Mars,+Jupiter,+Saturn,+Uranus,+Neptune
}
//..
print(Planet.caseCount)|48097|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|$]]

I define a reusable protocol which automatically performs the case count based on the approach posted by Nate Cook.

<pre><code>protocol CaseCountable {
 static var caseCount: Int { get }
}

extension CaseCountable where Self: RawRepresentable, Self.RawValue == Int {
 internal static var caseCount: Int {
 var count = 0
 while let _ = Self(rawValue: count) {
 count += 1
 }
 return count
 }
}
</code></pre>

Then I can reuse this protocol for example as follows:

<pre><code>enum Planet : Int, CaseCountable {
 case Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
}
//..
print(Planet.caseCount)
</code></pre>

blocks|key|4554668|text|当然，它不是动态的，但对于许多用途，您可以将静态变量添加到Enum中|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4554669|static+var+count:+Int{+return+7+}|offset|length|style|CODE|4554670|然后将其用作EnumName.count|4554671|entityMap^0|0|0|X|0|6|E|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|K|$]]

Of course, it's not dynamic but for many uses you can get by with a static var added to your Enum

<code>static var count: Int{ return 7 }</code>

and then use it as <code>EnumName.count</code>

blocks|key|4554706|text|创建静态allValues数组，如此answer所示|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4554707|enum+ProductCategory+:+String+{
+++++case+Washers+=+"washers",+Dryers+=+"dryers",+Toasters+=+"toasters"

+++++static+let+allValues+=+[Washers,+Dryers,+Toasters]
}

...

let+count+=+ProductCategory.allValues.count|code-block|syntax|javascript|4554708|当您要枚举值时，这也很有用，并且适用于所有枚举类型|4554709|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/24137319/1978471^0|I|6|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

Create static allValues array as shown in this <a href="https://stackoverflow.com/a/24137319/1978471">answer</a>

<pre><code>enum ProductCategory : String {
 case Washers = "washers", Dryers = "dryers", Toasters = "toasters"

 static let allValues = [Washers, Dryers, Toasters]
}

...

let count = ProductCategory.allValues.count
</code></pre>

This is also helpful when you want to enumerate the values, and works for all Enum types

blocks|key|4554772|text|我写了一个简单的扩展，它给所有原始值是整数的枚举一个count属性：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4554773|extension+RawRepresentable+where+RawValue:+IntegerType+{
++++static+var+count:+Int+{
++++++++var+i:+RawValue+=+0
++++++++while+let+_+=+Self(rawValue:+i)+{
++++++++++++i+=+i.successor()
++++++++}
++++++++return+Int(i.toIntMax())
++++}
}|code-block|syntax|javascript|4554774|不幸的是，它给OptionSetType提供了count属性，在那里它不能正常工作，所以这里是另一个版本，它需要显式地符合CaseCountable协议，以便您想要计数的任何枚举：|4554775|protocol+CaseCountable:+RawRepresentable+{}
extension+CaseCountable+where+RawValue:+IntegerType+{
++++static+var+count:+Int+{
++++++++var+i:+RawValue+=+0
++++++++while+let+_+=+Self(rawValue:+i)+{
++++++++++++i+=+i.successor()
++++++++}
++++++++return+Int(i.toIntMax())
++++}
}|4554776|它与Tom+Pelaia发布的方法非常相似，但适用于所有整数类型。|4554777|entityMap^0|Q|5|0|0|7|D|N|5|1P|D|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|14|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|R|$]]

I wrote a simple extension which gives all enums where raw value is integer a <code>count</code> property:

<pre><code>extension RawRepresentable where RawValue: IntegerType {
 static var count: Int {
 var i: RawValue = 0
 while let _ = Self(rawValue: i) {
 i = i.successor()
 }
 return Int(i.toIntMax())
 }
}
</code></pre>

Unfortunately it gives the <code>count</code> property to <code>OptionSetType</code> where it won't work properly, so here is another version which requires explicit conformance to <code>CaseCountable</code> protocol for any enum which cases you want to count:

<pre><code>protocol CaseCountable: RawRepresentable {}
extension CaseCountable where RawValue: IntegerType {
 static var count: Int {
 var i: RawValue = 0
 while let _ = Self(rawValue: i) {
 i = i.successor()
 }
 return Int(i.toIntMax())
 }
}
</code></pre>

It's very similar to the approach posted by Tom Pelaia, but works with all integer types.

blocks|key|48270|text|struct+HashableSequence<T:+Hashable>:+SequenceType+{
++++func+generate()+->+AnyGenerator<T>+{
++++++++var+i+=+0
++++++++return+AnyGenerator+{
++++++++++++let+next+=+withUnsafePointer(&i)+{+UnsafePointer<T>($0).memory+}
++++++++++++if+next.hashValue+==+i+{
++++++++++++++++i+%2B=+1
++++++++++++++++return+next
++++++++++++}
++++++++++++return+nil
++++++++}
++++}
}

extension+Hashable+{
++++static+func+enumCases()+->+Array<Self>+{
++++++++return+Array(HashableSequence())
++++}

++++static+var+enumCount:+Int+{
++++++++return+enumCases().enumCount
++++}
}

enum+E+{
++++case+A
++++case+B
++++case+C
}

E.enumCases()+//+[A,+B,+C]
E.enumCount+++//++3|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|48271|但在非枚举类型上使用时要小心。一些解决方法可能是：|unstyled|48272|struct+HashableSequence<T:+Hashable>:+SequenceType+{
++++func+generate()+->+AnyGenerator<T>+{
++++++++var+i+=+0
++++++++return+AnyGenerator+{
++++++++++++guard+sizeof(T)+==+1+else+{
++++++++++++++++return+nil
++++++++++++}
++++++++++++let+next+=+withUnsafePointer(&i)+{+UnsafePointer<T>($0).memory+}
++++++++++++if+next.hashValue+==+i+{
++++++++++++++++i+%2B=+1
++++++++++++++++return+next
++++++++++++}

++++++++++++return+nil
++++++++}
++++}
}

extension+Hashable+{
++++static+func+enumCases()+->+Array<Self>+{
++++++++return+Array(HashableSequence())
++++}

++++static+var+enumCount:+Int+{
++++++++return+enumCases().count
++++}
}

enum+E+{
++++case+A
++++case+B
++++case+C
}

Bool.enumCases()+++//+[false,+true]
Bool.enumCount+++++//+2
String.enumCases()+//+[]
String.enumCount+++//+0
Int.enumCases()++++//+[]
Int.enumCount++++++//+0
E.enumCases()++++++//+[A,+B,+C]
E.enumCount++++++++//+4|48273|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>struct HashableSequence&lt;T: Hashable&gt;: SequenceType {
 func generate() -&gt; AnyGenerator&lt;T&gt; {
 var i = 0
 return AnyGenerator {
 let next = withUnsafePointer(&amp;i) { UnsafePointer&lt;T&gt;($0).memory }
 if next.hashValue == i {
 i += 1
 return next
 }
 return nil
 }
 }
}

extension Hashable {
 static func enumCases() -&gt; Array&lt;Self&gt; {
 return Array(HashableSequence())
 }

 static var enumCount: Int {
 return enumCases().enumCount
 }
}

enum E {
 case A
 case B
 case C
}

E.enumCases() // [A, B, C]
E.enumCount // 3
</code></pre>

but be careful with usage on non-enum types. Some workaround could be:

<pre><code>struct HashableSequence&lt;T: Hashable&gt;: SequenceType {
 func generate() -&gt; AnyGenerator&lt;T&gt; {
 var i = 0
 return AnyGenerator {
 guard sizeof(T) == 1 else {
 return nil
 }
 let next = withUnsafePointer(&amp;i) { UnsafePointer&lt;T&gt;($0).memory }
 if next.hashValue == i {
 i += 1
 return next
 }

 return nil
 }
 }
}

extension Hashable {
 static func enumCases() -&gt; Array&lt;Self&gt; {
 return Array(HashableSequence())
 }

 static var enumCount: Int {
 return enumCases().count
 }
}

enum E {
 case A
 case B
 case C
}

Bool.enumCases() // [false, true]
Bool.enumCount // 2
String.enumCases() // []
String.enumCount // 0
Int.enumCases() // []
Int.enumCount // 0
E.enumCases() // [A, B, C]
E.enumCount // 4
</code></pre>

blocks|key|48303|text|它可以使用静态常量，该常量包含枚举的最后一个值加1。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|48304|enum+Color+:+Int+{
++++case++Red,+Orange,+Yellow,+Green,+Cyan,+Blue,+Purple

++++static+let+count:+Int+=+Color.Purple.rawValue+%2B+1

++++func+toUIColor()+->+UIColor{
++++++++switch+self+{
++++++++++++case+.Red:
++++++++++++++++return+UIColor.redColor()
++++++++++++case+.Orange:
++++++++++++++++return+UIColor.orangeColor()
++++++++++++case+.Yellow:
++++++++++++++++return+UIColor.yellowColor()
++++++++++++case+.Green:
++++++++++++++++return+UIColor.greenColor()
++++++++++++case+.Cyan:
++++++++++++++++return+UIColor.cyanColor()
++++++++++++case+.Blue:
++++++++++++++++return+UIColor.blueColor()
++++++++++++case+.Purple:
++++++++++++++++return+UIColor.redColor()
++++++++}
++++}
}|code-block|syntax|javascript|48305|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|$]]

It can use a static constant which contains the last value of the enumeration plus one. 

<pre><code>enum Color : Int {
 case Red, Orange, Yellow, Green, Cyan, Blue, Purple

 static let count: Int = Color.Purple.rawValue + 1

 func toUIColor() -&gt; UIColor{
 switch self {
 case .Red:
 return UIColor.redColor()
 case .Orange:
 return UIColor.orangeColor()
 case .Yellow:
 return UIColor.yellowColor()
 case .Green:
 return UIColor.greenColor()
 case .Cyan:
 return UIColor.cyanColor()
 case .Blue:
 return UIColor.blueColor()
 case .Purple:
 return UIColor.redColor()
 }
 }
}
</code></pre>

blocks|key|48378|text|你为什么把这一切都搞得这么复杂？Int枚举最简单的计数器是添加：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|48379|case+Count|offset|length|style|CODE|48380|最后。还有..。维奥拉-现在你知道了--又快又简单|48381|entityMap^0|0|0|A|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

Why do you make it all so complex? The SIMPLEST counter of Int enum is to add:

<code>case Count</code>

In the end. And... viola - now you have the count - fast and simple

blocks|key|4554934|text|或者，您可以在枚举外部定义_count，并静态地附加它：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4554935|let+_count:+Int+=+{
++++var+max:+Int+=+0
++++while+let+_+=+EnumName(rawValue:+max)+{+max+%2B=+1+}
++++return+max
}()

enum+EnumName:+Int+{
++++case+val0+=+0
++++case+val1
++++static+let+count+=+_count
}|code-block|syntax|javascript|4554936|这样，无论您创建了多少枚举，它都将只创建一次。|4554937|(如果static这样做，请删除此答案)|4554938|entityMap^0|D|6|0|0|0|3|6|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

Or you can just define the <code>_count</code> outside the enum, and attach it statically:

<pre><code>let _count: Int = {
 var max: Int = 0
 while let _ = EnumName(rawValue: max) { max += 1 }
 return max
}()

enum EnumName: Int {
 case val0 = 0
 case val1
 static let count = _count
}
</code></pre>

That way no matter how many enums you create, it'll only ever be created once.

(delete this answer if <code>static</code> does that)

blocks|key|48499|text|enum+EnumNameType:+Int+{
++++case+first
++++case+second
++++case+third

++++static+var+count:+Int+{+return+EnumNameType.third.rawValue+%2B+1+}
}

print(EnumNameType.count)+//3|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|48500|或|unstyled|48501|enum+EnumNameType:+Int+{
++++case+first
++++case+second
++++case+third
++++case+count
}

print(EnumNameType.count.rawValue)+//3|48502|*在Swift+4.2+(Xcode+10)上可以使用：|48503|enum+EnumNameType:+CaseIterable+{
++++case+first
++++case+second
++++case+third
}

print(EnumNameType.allCases.count)+//3|48504|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|P|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|M|3|-4|5|F|7|T|8|@]|9|@]|A|$]]]|N|$]]

<pre><code>enum EnumNameType: Int {
 case first
 case second
 case third

 static var count: Int { return EnumNameType.third.rawValue + 1 }
}

print(EnumNameType.count) //3
</code></pre>

OR

<pre><code>enum EnumNameType: Int {
 case first
 case second
 case third
 case count
}

print(EnumNameType.count.rawValue) //3
</code></pre>

*On Swift 4.2 (Xcode 10) can use:

<pre><code>enum EnumNameType: CaseIterable {
 case first
 case second
 case third
}

print(EnumNameType.allCases.count) //3
</code></pre>

blocks|key|48508|text|enum+WeekDays+:+String+,+CaseIterable
{
++case+monday+=+"Mon"
++case+tuesday+=+"Tue"
++case+wednesday+=+"Wed"
++case+thursday+=+"Thu"
++case+friday+=+"Fri"
++case+saturday+=+"Sat"
++case+sunday+=+"Sun"
}

var+weekdays+=+WeekDays.AllCases()

print("\(weekdays.count)")|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|48509|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 WeekDays : String , CaseIterable
{
 case monday = "Mon"
 case tuesday = "Tue"
 case wednesday = "Wed"
 case thursday = "Thu"
 case friday = "Fri"
 case saturday = "Sat"
 case sunday = "Sun"
}

var weekdays = WeekDays.AllCases()

print("\(weekdays.count)")
</code></pre>

How can I determine the number of cases in a Swift enum?

(I would like to avoid <a href="https://stackoverflow.com/a/24137319/17294">manually enumerating through all the values</a>, or using the old "<a href="https://stackoverflow.com/a/14717179/17294">enum_count trick</a>" if possible.)

How do I get the count of a Swift enum?

Swift

Xcode

如何确定Swift枚举中的案例数？(如果可能的话，我想避免使用，或者使用旧的"“。)

问如何获取Swift枚举的计数？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何获取Swift枚举的计数？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何获取Swift枚举的计数？
EN