Como enumerar um enum com o tipo String?

enum Suit: String { case spades = "♠" case hearts = "♥" case diamonds = "♦" case clubs = "♣" } 

Por exemplo, como posso fazer algo como:

 for suit in Suit { // do something with suit print(suit.rawValue) } 

Exemplo resultante:

 ♠ ♥ ♦ ♣ 

Swift 4.2+

Começando com o Swift 4.2 (com o Xcode 10), basta adicionar a conformidade do protocolo ao CaseIterable para se beneficiar de allCases :

 extension Suit: CaseIterable {} 

Então isto irá imprimir todos os valores possíveis:

 Suit.allCases.forEach { print($0.rawValue) } 

Compatibilidade com versões anteriores do Swift (3.xe 4.x)

Apenas imite a implementação do Swift 4.2:

 #if !swift(>=4.2) public protocol CaseIterable { associatedtype AllCases: Collection where AllCases.Element == Self static var allCases: AllCases { get } } extension CaseIterable where Self: Hashable { static var allCases: [Self] { return [Self](AnySequence { () -> AnyIterator in var raw = 0 var first: Self? return AnyIterator { let current = withUnsafeBytes(of: &raw) { $0.load(as: Self.self) } if raw == 0 { first = current } else if current == first { return nil } raw += 1 return current } }) } } #endif 

Esta postagem é relevante aqui https://www.swift-studies.com/blog/2014/6/10/enumerating-enums-in-swift

Essencialmente, a solução proposta é

 enum ProductCategory : String { case Washers = "washers", Dryers = "dryers", Toasters = "toasters" static let allValues = [Washers, Dryers, Toasters] } for category in ProductCategory.allValues{ //Do something } 

Eu fiz uma function de utilidade iterateEnum() para iterar casos para tipos arbitrários de enum .

Aqui está o exemplo de uso:

 enum Suit:String { case Spades = "♠" case Hearts = "♥" case Diamonds = "♦" case Clubs = "♣" } for f in iterateEnum(Suit) { println(f.rawValue) } 

saídas:

 ♠ ♥ ♦ ♣ 

Mas, isso é somente para fins de teste ou debugging : isso depende de vários comportamentos de compilador atuais não documentados (Swift1.1). Então use-o por seu próprio risco 🙂

Aqui está o código:

 func iterateEnum(_: T.Type) -> GeneratorOf { var cast: (Int -> T)! switch sizeof(T) { case 0: return GeneratorOf(GeneratorOfOne(unsafeBitCast((), T.self))) case 1: cast = { unsafeBitCast(UInt8(truncatingBitPattern: $0), T.self) } case 2: cast = { unsafeBitCast(UInt16(truncatingBitPattern: $0), T.self) } case 4: cast = { unsafeBitCast(UInt32(truncatingBitPattern: $0), T.self) } case 8: cast = { unsafeBitCast(UInt64($0), T.self) } default: fatalError("cannot be here") } var i = 0 return GeneratorOf { let next = cast(i) return next.hashValue == i++ ? next : nil } } 

A ideia subjacente é:

  • Representação de memory de enum – excluindo enum s com tipos associados – é apenas um índice de casos, quando a contagem dos casos é 2...256 , é idêntica a UInt8 , quando 257...65536 , é UInt16 e assim por diante. Portanto, pode ser unsafeBitcast de tipos inteiros correspondentes sem sinal.
  • .hashValue dos valores enum é o mesmo que o índice do caso.
  • .hashValue dos valores enum bitcasted do índice inválido é 0

ADICIONADO:

Revisado para o Swift2 e implementou ideias de casting a partir da resposta do @ Kametrixom

 func iterateEnum(_: T.Type) -> AnyGenerator { var i = 0 return anyGenerator { let next = withUnsafePointer(&i) { UnsafePointer($0).memory } return next.hashValue == i++ ? next : nil } } 

ADICIONADO: revisado para Swift3

 func iterateEnum(_: T.Type) -> AnyIterator { var i = 0 return AnyIterator { let next = withUnsafePointer(to: &i) { $0.withMemoryRebound(to: T.self, capacity: 1) { $0.pointee } } if next.hashValue != i { return nil } i += 1 return next } } 

ADICIONADO: revisado para Swift3.0.1

 func iterateEnum(_: T.Type) -> AnyIterator { var i = 0 return AnyIterator { let next = withUnsafeBytes(of: &i) { $0.load(as: T.self) } if next.hashValue != i { return nil } i += 1 return next } } 

As outras soluções funcionam, mas todas elas pressupõem, por exemplo, o número de posições e ações possíveis, ou qual pode ser a primeira e última sorting. É verdade que o layout de um baralho de cartas provavelmente não vai mudar muito no futuro previsível. Em geral, no entanto, é melhor escrever códigos que fazem o mínimo possível de suposições. Minha solução:

Eu adicionei um tipo raw ao terno enum, então eu posso usar Suit (rawValue 🙂 para acessar os cases do Suit:

 enum Suit: Int { case Spades = 1 case Hearts, Diamonds, Clubs func simpleDescription() -> String { switch self { case .Spades: return "spades" case .Hearts: return "hearts" case .Diamonds: return "diamonds" case .Clubs: return "clubs" } } func color() -> String { switch self { case .Spades: return "black" case .Clubs: return "black" case .Diamonds: return "red" case .Hearts: return "red" } } } enum Rank: Int { case Ace = 1 case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten case Jack, Queen, King func simpleDescription() -> String { switch self { case .Ace: return "ace" case .Jack: return "jack" case .Queen: return "queen" case .King: return "king" default: return String(self.rawValue) } } } 

Abaixo a implementação do método createDeck () do Card. init (rawValue 🙂 é um inicializador fiável e retorna um opcional. Desembalando e verificando seu valor em ambas as declarações, não há necessidade de assumir o número de casos de Rank ou Suit:

 struct Card { var rank: Rank var suit: Suit func simpleDescription() -> String { return "The \(rank.simpleDescription()) of \(suit.simpleDescription())" } func createDeck() -> [Card] { var n = 1 var deck = [Card]() while let rank = Rank(rawValue: n) { var m = 1 while let suit = Suit(rawValue: m) { deck.append(Card(rank: rank, suit: suit)) m += 1 } n += 1 } return deck } } 

Aqui está como chamar o método createDeck:

 let card = Card(rank: Rank.Ace, suit: Suit.Clubs) let deck = card.createDeck() 

A segunda resposta que realmente funciona

Então eu tropecei nos bits e bytes e criei uma extensão (que mais tarde descobri funciona muito similar à resposta de @rintaro ). É utilizável assim:

 enum E : EnumCollection { case A, B, C } Array(E.cases()) // [A, B, C] 

Notável é que é utilizável em qualquer enum (sem valores associados). Observe que isso não funciona para enums que não possuem casos.

aviso Legal

Como na resposta de @rintaro , esse código usa a representação subjacente de um enum. Esta representação não é documentada e pode mudar no futuro, o que a quebraria -> Eu não recomendo o uso disso na produção.

EDIT: Tem sido cerca de um ano e isso ainda funciona.

Código (Swift 2.2, Xcode 7.3.1)

 protocol EnumCollection : Hashable {} extension EnumCollection { static func cases() -> AnySequence { typealias S = Self return AnySequence { () -> AnyGenerator in var raw = 0 return AnyGenerator { let current : Self = withUnsafePointer(&raw) { UnsafePointer($0).memory } guard current.hashValue == raw else { return nil } raw += 1 return current } } } } 

Código (Swift 3, Xcode 8.1)

 protocol EnumCollection : Hashable {} extension EnumCollection { static func cases() -> AnySequence { typealias S = Self return AnySequence { () -> AnyIterator in var raw = 0 return AnyIterator { let current : Self = withUnsafePointer(to: &raw) { $0.withMemoryRebound(to: S.self, capacity: 1) { $0.pointee } } guard current.hashValue == raw else { return nil } raw += 1 return current } } } } 

(Eu não tenho idéia porque eu preciso das typealias , mas o compilador reclama sem ele)

(Eu fiz grandes modificações nessa resposta, veja edições de versões anteriores)

Você pode iterar por meio de um enum implementando o protocolo ForwardIndexType .

O protocolo ForwardIndexType requer que você defina uma function successor() para percorrer os elementos.

 enum Rank: Int, ForwardIndexType { case Ace = 1 case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten case Jack, Queen, King // ... other functions // Option 1 - Figure it out by hand func successor() -> Rank { switch self { case .Ace: return .Two case .Two: return .Three // ... etc. default: return .King } } // Option 2 - Define an operator! func successor() -> Rank { return self + 1 } } // NOTE: The operator is defined OUTSIDE the class func + (left: Rank, right: Int) -> Rank { // I'm using to/from raw here, but again, you can use a case statement // or whatever else you can think of return left == .King ? .King : Rank(rawValue: left.rawValue + right)! } 

A iteração em um intervalo aberto ou fechado ( ..< ou ... ) chamará internamente a function successor() , que permite escrever isto:

 // Under the covers, successor(Rank.King) and successor(Rank.Ace) are called to establish limits for r in Rank.Ace...Rank.King { // Do something useful } 

Em princípio, é possível fazer desta forma assumindo que você não usa a atribuição de valores brutos para os casos do enum:

 enum RankEnum: Int { case Ace case One case Two } class RankEnumGenerator : Generator { var i = 0 typealias Element = RankEnum func next() -> Element? { let r = RankEnum.fromRaw(i) i += 1 return r } } extension RankEnum { static func enumerate() -> SequenceOf { return SequenceOf({ RankEnumGenerator() }) } } for r in RankEnum.enumerate() { println("\(r.toRaw())") } 

Atualizado para o Swift 2.2 +

 func iterateEnum(_: T.Type) -> AnyGenerator { var i = 0 return AnyGenerator { let next = withUnsafePointer(&i) { UnsafePointer($0).memory } if next.hashValue == i { i += 1 return next } else { return nil } } } 

é um código atualizado para o formulário Swift 2.2 @ Kametrixom é um swer

Para o Swift 3.0+ (muito obrigado ao @Philip )

 func iterateEnum(_: T.Type) -> AnyIterator { var i = 0 return AnyIterator { let next = withUnsafePointer(&i) { UnsafePointer($0).pointee } if next.hashValue == i { i += 1 return next } else { return nil } } } 

Se você der ao enum um valor Int bruto , o loop será muito mais fácil.

Por exemplo, você pode usar anyGenerator para obter um gerador que possa enumerar seus valores:

 enum Suit: Int, CustomStringConvertible { case Spades, Hearts, Diamonds, Clubs var description: String { switch self { case .Spades: return "Spades" case .Hearts: return "Hearts" case .Diamonds: return "Diamonds" case .Clubs: return "Clubs" } } static func enumerate() -> AnyGenerator { var nextIndex = Spades.rawValue return anyGenerator { Suit(rawValue: nextIndex++) } } } // You can now use it like this: for suit in Suit.enumerate() { suit.description } // or like this: let allSuits: [Suit] = Array(Suit.enumerate()) 

No entanto, isso parece um padrão bastante comum, não seria bom se pudéssemos tornar enumerável qualquer tipo de enumeração simplesmente obedecendo a um protocolo? Bem com o Swift 2.0 e extensões de protocolo, agora podemos!

Basta adicionar isso ao seu projeto:

 protocol EnumerableEnum { init?(rawValue: Int) static func firstValue() -> Int } extension EnumerableEnum { static func enumerate() -> AnyGenerator { var nextIndex = firstRawValue() return anyGenerator { Self(rawValue: nextIndex++) } } static func firstRawValue() -> Int { return 0 } } 

Agora, toda vez que você criar um enum (contanto que ele tenha um valor bruto Int), você poderá torná-lo enumerável conforme o protocolo:

 enum Rank: Int, EnumerableEnum { case Ace, Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten, Jack, Queen, King } // ... for rank in Rank.enumerate() { ... } 

Se os valores de enum não começarem com 0 (o padrão), substitua o método firstRawValue :

 enum DeckColor: Int, EnumerableEnum { case Red = 10, Blue, Black static func firstRawValue() -> Int { return Red.rawValue } } // ... let colors = Array(DeckColor.enumerate()) 

A última class Suit, incluindo a substituição de simpleDescription pelo protocolo CustomStringConvertible mais padrão , terá a seguinte aparência:

 enum Suit: Int, CustomStringConvertible, EnumerableEnum { case Spades, Hearts, Diamonds, Clubs var description: String { switch self { case .Spades: return "Spades" case .Hearts: return "Hearts" case .Diamonds: return "Diamonds" case .Clubs: return "Clubs" } } } // ... for suit in Suit.enumerate() { print(suit.description) } 

EDITAR:

Sintaxe do Swift 3 :

 protocol EnumerableEnum { init?(rawValue: Int) static func firstRawValue() -> Int } extension EnumerableEnum { static func enumerate() -> AnyIterator { var nextIndex = firstRawValue() let iterator: AnyIterator = AnyIterator { defer { nextIndex = nextIndex + 1 } return Self(rawValue: nextIndex) } return iterator } static func firstRawValue() -> Int { return 0 } } 

Eu gosto desta solução que eu reuni depois de encontrar esta página: List comprehension in Swift

Ele usa Int raws em vez de Strings, mas evita digitar duas vezes, permite personalizar os intervalos e não codifica valores brutos.

 enum Suit: Int { case None case Spade, Heart, Diamond, Club static let allRawValues = Suit.Spade.rawValue...Suit.Club.rawValue static let allCases = Array(allRawValues.map{ Suit(rawValue: $0)! }) } enum Rank: Int { case Joker case Two, Three, Four, Five, Six case Seven, Eight, Nine, Ten case Jack, Queen, King, Ace static let allRawValues = Rank.Two.rawValue...Rank.Ace.rawValue static let allCases = Array(allRawValues.map{ Rank(rawValue: $0)! }) } func makeDeck(withJoker withJoker: Bool) -> [Card] { var deck = [Card]() for suit in Suit.allCases { for rank in Rank.allCases { deck.append(Card(suit: suit, rank: rank)) } } if withJoker { deck.append(Card(suit: .None, rank: .Joker)) } return deck } 

Eu me encontrei fazendo todos os .allValues todo o meu código. Eu finalmente descobri uma maneira de simplesmente estar em conformidade com um protocolo Iteratable e ter um método rawValues() .

 protocol Iteratable {} extension RawRepresentable where Self: RawRepresentable { static func iterateEnum(_: T.Type) -> AnyIterator { var i = 0 return AnyIterator { let next = withUnsafePointer(to: &i) { $0.withMemoryRebound(to: T.self, capacity: 1) { $0.pointee } } if next.hashValue != i { return nil } i += 1 return next } } } extension Iteratable where Self: RawRepresentable, Self: Hashable { static func hashValues() -> AnyIterator { return iterateEnum(self) } static func rawValues() -> [Self.RawValue] { return hashValues().map({$0.rawValue}) } } // Example enum Grocery: String, Iteratable { case Kroger = "kroger" case HEB = "heb" case Randalls = "randalls" } let groceryHashes = Grocery.hashValues() // AnyIterator let groceryRawValues = Grocery.rawValues() // ["kroger", "heb", "randalls"] 
 enum Rank: Int { ... static let ranks = (Rank.Ace.rawValue ... Rank.King.rawValue).map{Rank(rawValue: $0)! } } enum Suit { ... static let suits = [Spades, Hearts, Diamonds, Clubs] } struct Card { ... static func fullDesk() -> [Card] { var desk: [Card] = [] for suit in Suit.suits { for rank in Rank.ranks { desk.append(Card(rank: rank,suit: suit)) } } return desk } } 

Que tal agora?

EDIT: proposta de evolução Swift SE-0194 Derived coleção de casos Enum propõe uma solução de nível para este problema. Nós vemos isso no Swift 4.2 e mais recente. A proposta também aponta algumas soluções similares a algumas já mencionadas aqui, mas pode ser interessante ver, no entanto.

Eu também vou manter meu post original por completo.


Esta é mais uma abordagem baseada na resposta de @Peymmankh, adaptada para o Swift 3 .

 public protocol EnumCollection : Hashable {} extension EnumCollection { public static func allValues() -> [Self] { typealias S = Self let retVal = AnySequence { () -> AnyIterator in var raw = 0 return AnyIterator { let current = withUnsafePointer(to: &raw) { $0.withMemoryRebound(to: S.self, capacity: 1) { $0.pointee } } guard current.hashValue == raw else { return nil } raw += 1 return current } } return [S](retVal) } } 

Desculpe, minha resposta foi específica para como eu usei este post no que eu precisava fazer. Para aqueles que se deparam com essa questão, procurando uma maneira de encontrar um caso dentro de um enum, esta é a maneira de fazê-lo (novo no Swift 2):

Editar: o camelCase minúsculo agora é o padrão para os valores de enum do Swift 3

 // From apple docs: If the raw-value type is specified as String and you don't assign values to the cases explicitly, each unassigned case is implicitly assigned a string with the same text as the name of that case. enum Theme: String { case white, blue, green, lavender, grey } func loadTheme(theme: String) { // this checks the string against the raw value of each enum case (note that the check could result in a nil value, since it's an optional, which is why we introduce the if/let block if let testTheme = Theme(rawValue: theme) { // testTheme is guaranteed to have an enum value at this point self.someOtherFunction(testTheme) } } 

Para aqueles que se perguntam sobre a enumeração em um enum, as respostas dadas nesta página que incluem um var / let estático contendo uma matriz de todos os valores enum estão corretas. O último código de exemplo da Apple para o tvOS contém exatamente essa mesma técnica.

Dito isto, eles devem construir um mecanismo mais conveniente para a linguagem (Apple, você está ouvindo?)!

No Swift 3, quando o enum subjacente tem {rawValue} s, você pode implementar o protocolo {Strideable}. As vantagens são que nenhuma matriz de valores é criada como em outras sugestões, e que a instrução padrão Swift “para i in …” funciona, o que torna a syntax agradável.

 // "Int" to get rawValue, and {Strideable} so we can iterate enum MyColorEnum : Int, Strideable { case Red case Green case Blue case Black //-------- required by {Strideable} typealias Stride = Int func advanced(by n:Stride) -> MyColorEnum { var next = self.rawValue + n if next > MyColorEnum.Black.rawValue { next = MyColorEnum.Black.rawValue } return MyColorEnum(rawValue: next)! } func distance(to other: MyColorEnum) -> Int { return other.rawValue - self.rawValue } //-------- just for printing func simpleDescription() -> String { switch self { case .Red: return "Red" case .Green: return "Green" case .Blue: return "Blue" case .Black: return "Black" } } } // this is how you use it: for i in MyColorEnum.Red ... MyColorEnum.Black { print("ENUM: \(i)") } 

Você pode tentar enumerar assim

 enum Planet: String { case Mercury case Venus case Earth case Mars static var enumerate: [Planet] { var a: [Planet] = [] switch Planet.Mercury { case .Mercury: a.append(.Mercury); fallthrough case .Venus: a.append(.Venus); fallthrough case .Earth: a.append(.Earth); fallthrough case .Mars: a.append(.Mars) } return a } } Planet.enumerate // [Mercury, Venus, Earth, Mars] 

Foi com isso que acabei indo; Eu acho que isso atinge o equilíbrio certo de legibilidade e facilidade de manutenção.

 struct Card { // ... static func deck() -> Card[] { var deck = Card[]() for rank in Rank.Ace.toRaw()...Rank.King.toRaw() { for suit in [Suit.Spades, .Hearts, .Clubs, .Diamonds] { let card = Card(rank: Rank.fromRaw(rank)!, suit: suit) deck.append(card) } } return deck } let deck = Card.deck() 

O experimento foi: EXPERIMENTO

Adicione um método ao Card que crie um baralho cheio de cartas, com um card de cada combinação de rank e naipe.

Então, sem modificar ou aprimorar o código dado além de adicionar o método (e sem usar material que ainda não foi ensinado), eu criei esta solução:

 struct Card { var rank: Rank var suit: Suit func simpleDescription() -> String { return "The \(rank.simpleDescription()) of \(suit.simpleDescription())" } func createDeck() -> [Card] { var deck: [Card] = [] for rank in Rank.Ace.rawValue...Rank.King.rawValue { for suit in Suit.Spades.rawValue...Suit.Clubs.rawValue { let card = Card(rank: Rank(rawValue: rank)!, suit: Suit(rawValue: suit)!) //println(card.simpleDescription()) deck += [card] } } return deck } } let threeOfSpades = Card(rank: .Three, suit: .Spades) let threeOfSpadesDescription = threeOfSpades.simpleDescription() let deck = threeOfSpades.createDeck() 

Tal como acontece com @Kametrixom resposta aqui , acredito que retornando uma matriz seria melhor do que retornar AnySequence, uma vez que você pode ter access a todas as guloseimas da matriz, como contagem, etc.

Aqui está a reescrita:

 public protocol EnumCollection : Hashable {} extension EnumCollection { public static func allValues() -> [Self] { typealias S = Self let retVal = AnySequence { () -> AnyGenerator in var raw = 0 return AnyGenerator { let current : Self = withUnsafePointer(&raw) { UnsafePointer($0).memory } guard current.hashValue == raw else { return nil } raw += 1 return current } } return [S](retVal) } } 

Enums have toRaw() and fromRaw() methods so if your raw value is an Int, you can iterate from the first to last enum:

 enum Suit: Int { case Spades = 1 case Hearts, Diamonds, Clubs func simpleDescription() -> String { switch self { case .Spades: return "spades" case .Hearts: return "hearts" case .Diamonds: return "diamonds" case .Clubs: return "clubs" } } } for i in Suit.Spades.toRaw()...Suit.Clubs.toRaw() { if let covertedSuit = Suit.fromRaw(i) { let description = covertedSuit.simpleDescription() } } 

One gotcha is that you need to test for optional values before running the simpleDescription method, so we set convertedSuit to our value first and then set a constant to convertedSuit.simpleDescription()

This seems like a hack but if you use raw values you can do something like this

 enum Suit: Int { case Spades = 0, Hearts, Diamonds, Clubs ... } var suitIndex = 0 while var suit = Suit.fromRaw(suitIndex++) { ... } 

Here’s my suggested approach. It’s not completely satisfactory (I’m very new to Swift and OOP!) but maybe someone can refine it. The idea is to have each enum provide its own range information as .first and .last properties. It adds just two lines of code to each enum: still a bit hard-coded, but at least it’s not duplicating the whole set. It does require modifying the Suit enum to be an Int like the Rank enum is, instead of untyped.

Rather than echo the whole solution, here’s the code I added to the Rank enum, somewhere after the case statements (Suit enum is similar):

 var first: Int { return Ace.toRaw() } var last: Int { return King.toRaw() } 

and the loop I used to build the deck as an array of String. (The problem definition did not state how the deck was to be structured.)

 func createDeck() -> [String] { var deck: [String] = [] var card: String for r in Rank.Ace.first...Rank.Ace.last { for s in Suit.Hearts.first...Suit.Hearts.last { card = Rank.simpleDescription( Rank.fromRaw(r)!)() + " of " + Suit.simpleDescription( Suit.fromRaw(s)!)() deck.append( card) } } return deck } 

It’s unsatisfactory because the properties are associated to an element rather than to the enum. But it does add clarity to the ‘for’ loops. I’d like it to say Rank.first instead of Rank.Ace.first. It works (with any element), but it’s ugly. Can someone show how to elevate that to the enum level?

And to make it work, I lifted the createDeck method out of the Card struct… could not figure out how to get a [String] array returned from that struct, and that seems a bad place to put such a method anyway.

I did it using computed property, which returns the array of all values (thanks to this post http://natecook.com/blog/2014/10/loopy-random-enum-ideas/ ). However it also uses int raw-values, but I don’t need to repeat all members of enumeration in separate property.

UPDATE Xcode 6.1 changed a bit a way how to get enum member using raw value, so I fixed listing. Also fixed small error with wrong first raw value

 enum ValidSuits:Int{ case Clubs=0, Spades, Hearts, Diamonds func description()->String{ switch self{ case .Clubs: return "♣︎" case .Spades: return "♠︎" case .Diamonds: return "♦︎" case .Hearts: return "♥︎" } } static var allSuits:[ValidSuits]{ return Array( SequenceOf { () -> GeneratorOf in var i=0 return GeneratorOf{ return ValidSuits(rawValue: i++) } } ) } } 

While dealing with Swift 2.0 here is my suggestion:

I have added the raw type to Suit enum

 enum Suit: Int { 

então:

 struct Card { var rank: Rank var suit: Suit func fullDeck()-> [Card] { var deck = [Card]() for i in Rank.Ace.rawValue...Rank.King.rawValue { for j in Suit.Spades.rawValue...Suit.Clubs.rawValue { deck.append(Card(rank:Rank(rawValue: i)! , suit: Suit(rawValue: j)!)) } } return deck } } 

For enum representing Int

 enum Filter: Int { case salary case experience case technology case unutilized case unutilizedHV static let allRawValues = salary.rawValue...unutilizedHV.rawValue // First to last case static let allValues = allRawValues.map { Filter(rawValue: $0)!.rawValue } } 

Chame assim:

 print(Filter.allValues) 

Impressões:

[0, 1, 2, 3, 4]


For enum representing String

 enum Filter: Int { case salary case experience case technology case unutilized case unutilizedHV static let allRawValues = salary.rawValue...unutilizedHV.rawValue // First to last case static let allValues = allRawValues.map { Filter(rawValue: $0)!.description } } extension Filter: CustomStringConvertible { var description: String { switch self { case .salary: return "Salary" case .experience: return "Experience" case .technology: return "Technology" case .unutilized: return "Unutilized" case .unutilizedHV: return "Unutilized High Value" } } } 

Call it

 print(Filter.allValues) 

Impressões:

[“Salary”, “Experience”, “Technology”, “Unutilized”, “Unutilized High Value”]

Outra solução

 enum Suit: String { case spades = "♠" case hearts = "♥" case diamonds = "♦" case clubs = "♣" static var count: Int { return 4 } init(index: Int) { switch index { case 0: self = .spades case 1: self = .hearts case 2: self = .diamonds default: self = .clubs } } } for i in 0.. 

This is a pretty old post, from Swift 2.0. There are now some better solutions here that use newer features of swift 3.0: Iterating through an Enum in Swift 3.0

And on this question there is a solution that uses a new feature of (the not-yet-released as I write this edit) Swift 4.2: How do I get the count of a Swift enum?


There are lots of good solutions in this thread and others however some of them are very complicated. I like to simplify as much as possible. Here is a solution which may or may not work for different needs but I think it works well in most cases:

 enum Number: String { case One case Two case Three case Four case EndIndex func nextCase () -> Number { switch self { case .One: return .Two case .Two: return .Three case .Three: return .Four case .Four: return .EndIndex /* Add all additional cases above */ case .EndIndex: return .EndIndex } } static var allValues: [String] { var array: [String] = Array() var number = Number.One while number != Number.EndIndex { array.append(number.rawValue) number = number.nextCase() } return array } } 

To iterate:

 for item in Number.allValues { print("number is: \(item)") } 

Here a method I use to both iterate an enum, and provide multiple values types from one enum

 enum IterateEnum: Int { case Zero case One case Two case Three case Four case Five case Six case Seven //tuple allows multiple values to be derived from the enum case, and //since it is using a switch with no default, if a new case is added, //a compiler error will be returned if it doesn't have a value tuple set var value: (french:String, spanish:String, japanese:String) { switch self { case .Zero: return (french:"zéro", spanish:"cero", japanese:"nuru") case .One: return (french:"un", spanish:"uno", japanese:"ichi") case .Two: return (french:"deux", spanish:"dos", japanese:"ni") case .Three: return (french:"trois", spanish:"tres", japanese:"san") case .Four: return (french:"quatre", spanish:"cuatro", japanese:"shi") case .Five: return (french:"cinq", spanish:"cinco", japanese:"go") case .Six: return (french:"six", spanish:"seis", japanese:"roku") case .Seven: return (french:"sept", spanish:"siete", japanese:"shichi") } } //Used to iterate enum or otherwise access enum case by index order. //Iterate by looping until it returns nil static func item(index:Int) -> IterateEnum? { return IterateEnum.init(rawValue: index) } static func numberFromSpanish(number:String) -> IterateEnum? { return findItem { $0.value.spanish == number } } //use block to test value property to retrieve the enum case static func findItem(predicate:((_:IterateEnum)->Bool)) -> IterateEnum? { var enumIndex:Int = -1 var enumCase:IterateEnum? //Iterate until item returns nil repeat { enumIndex += 1 enumCase = IterateEnum.item(index: enumIndex) if let eCase = enumCase { if predicate(eCase) { return eCase } } } while enumCase != nil return nil } } var enumIndex:Int = -1 var enumCase:IterateEnum? //Iterate until item returns nil repeat { enumIndex += 1 enumCase = IterateEnum.item(index: enumIndex) if let eCase = enumCase { print("The number \(eCase) in french: \(eCase.value.french), spanish: \(eCase.value.spanish), japanese: \(eCase.value.japanese)") } } while enumCase != nil print("Total of \(enumIndex) cases") let number = IterateEnum.numberFromSpanish(number: "siete") print("siete in japanese: \((number?.value.japanese ?? "Unknown"))") 

This is the output:

The number Zero in french: zéro, spanish: cero, japanese: nuru
The number One in french: un, spanish: uno, japanese: ichi
The number Two in french: deux, spanish: dos, japanese: ni
The number Three in french: trois, spanish: tres, japanese: san
The number Four in french: quatre, spanish: cuatro, japanese: shi
The number Five in french: cinq, spanish: cinco, japanese: go
The number Six in french: six, spanish: seis, japanese: roku
The number Seven in french: sept, spanish: siete, japanese: shichi

Total of 8 cases

siete in japanese: shichi


UPDATE

I recently created a protocol to handle the enumeration. The protocol requires an enum with an Int raw value:

 protocol EnumIteration { //Used to iterate enum or otherwise access enum case by index order. Iterate by looping until it returns nil static func item(index:Int) -> Self? static func iterate(item:((index:Int, enumCase:Self)->()), completion:(()->())?) { static func findItem(predicate:((enumCase:Self)->Bool)) -> Self? static func count() -> Int } extension EnumIteration where Self: RawRepresentable, Self.RawValue == Int { //Used to iterate enum or otherwise access enum case by index order. Iterate by looping until it returns nil static func item(index:Int) -> Self? { return Self.init(rawValue: index) } static func iterate(item:((index:Int, enumCase:Self)->()), completion:(()->())?) { var enumIndex:Int = -1 var enumCase:Self? //Iterate until item returns nil repeat { enumIndex += 1 enumCase = Self.item(enumIndex) if let eCase = enumCase { item(index: enumIndex, enumCase: eCase) } } while enumCase != nil completion?() } static func findItem(predicate:((enumCase:Self)->Bool)) -> Self? { var enumIndex:Int = -1 var enumCase:Self? //Iterate until item returns nil repeat { enumIndex += 1 enumCase = Self.item(enumIndex) if let eCase = enumCase { if predicate(enumCase:eCase) { return eCase } } } while enumCase != nil return nil } static func count() -> Int { var enumIndex:Int = -1 var enumCase:Self? //Iterate until item returns nil repeat { enumIndex += 1 enumCase = Self.item(enumIndex) } while enumCase != nil //last enumIndex (when enumCase == nil) is equal to the enum count return enumIndex } } 

I have used the below method, the assumption is that I know which is the last value in the Rank enum and all the ranks have incremental values after Ace

I prefer this way as it is clean and small, easy to understand

  func cardDeck() -> Card[] { var cards: Card[] = [] let minRank = Rank.Ace.toRaw() let maxRank = Rank.King.toRaw() for rank in minRank...maxRank { if var convertedRank: Rank = Rank.fromRaw(rank) { cards.append(Card(rank: convertedRank, suite: Suite.Clubs)) cards.append(Card(rank: convertedRank, suite: Suite.Diamonds)) cards.append(Card(rank: convertedRank, suite: Suite.Hearts)) cards.append(Card(rank: convertedRank, suite: Suite.Spades)) } } return cards } 

There is a clever way, and frustrating as it is it illustrates the difference between the two different kinds of enums.

Tente isto:

  func makeDeck() -> Card[] { var deck: Card[] = [] var suits: Suit[] = [.Hearts, .Diamonds, .Clubs, .Spades] for i in 1...13 { for suit in suits { deck += Card(rank: Rank.fromRaw(i)!, suit: suit) } } return deck } 

The deal is that an enum backed by numbers (raw values) is implicitly explicitly ordered, whereas an enum that isn’t backed by numbers is explicitly implicitly unordered.

Eg when we give the enum values numbers, the language is cunning enough to figure out what order the numbers are in. If on the other hand we don’t give it any ordering, when we try to iterate over the values the language throws its hands up in the air and goes “yes, but which one do you want to go first???”

Other languages which can do this (iterating over unordered enums) might be the same languages where everything is ‘under the hood’ actually a map or dictionary, and you can iterate over the keys of a map, whether there’s any logical ordering or not.

So the trick is to provide it with something that is explicitly ordered, in this case instances of the suits in an array in the order we want. As soon as you give it that, Swift is like “well why didn’t you say so in the first place?”

The other shorthand trick is to use the forcing operator on the fromRaw function. This illustrates another ‘gotcha’ about enums, that the range of possible values to pass in is often larger than the range of enums. For instance if we said Rank.fromRaw(60) there wouldn’t be a value returned, so we’re using the optional feature of the language, and where we start using optionals, forcing will soon follow. (Or alternately the if let construction which still seems a bit weird to me)