Boucle à travers les valeurs enum dans Swift [dupliquer]

cette question a déjà une réponse ici:

  • comment énumérer un enum avec le type String? 41 réponses

est-il possible de passer en boucle à travers les valeurs enum de Swift? Ou quelle est l'alternative?

je travaille avec le guide de langage Swift D'Apple, et je je suis tombé sur cet exemple sur enums.

//  EXPERIMENT
//
//  Add a method to Card that creates a full deck of cards, 
//  with one card of each combination of rank and suit.

struct Card {
    var rank: Rank
    var suit: Suit
    func simpleDescription() -> String {
        return "The (rank.simpleDescription()) of (suit.simpleDescription())"
    }
}
let threeOfSpades = Card(rank: .Three, suit: .Spades)
let threeOfSpadesDescription = threeOfSpades.simpleDescription()

enum Suit {
    case Spades, Hearts, Diamonds, Clubs
    func simpleDescription() -> String {
        switch self {
        case .Spades:
            return "spades"
        case .Hearts:
            return "hearts"
        case .Diamonds:
            return "diamonds"
        case .Clubs:
            return "clubs"
        }
    }
}

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.toRaw())
        }
    }
}

Extrait De: Apple Inc. "Le Langage De Programmation Swift."iBooks. https://itun.es/us/jEUH0.l

j'ai essayé ce qui suit, mais les docs disent que les énums dans Swift ne sont pas assignés aux valeurs entières sous-jacentes comme dans C, donc je suis probablement en train d'aboyer dans le mauvais arbre.

Est-il une meilleure façon de résoudre ce problème?

func deck() -> Card[]{
    var deck: Card[]
    for s in Suit {
        for r in Rank {
            deck += Card(rank: r, suit: s)
        }
    }
    return deck
}

func deck2() -> Card[]{
    var deck: Card[]
    for var s: Suit = .Spades; s <= .Clubs; s++ {
        for var r: Rank = .Ace; r <= .King; r++ {
            deck += Card(rank: r, suit: s)
        }
    }
    return deck
}
30
demandé sur Pramod More 2014-06-05 17:29:43

1 réponses

y a-t-il un autre moyen? Assurer. Est - ce mieux , c'est à vous de décider:

func generateDeck() -> Card[]
{
    let ranksPerSuit = 13
    var deck = Card[]()

    for index in 0..52
    {
        let suit = Suit.fromRaw(index / ranksPerSuit)
        let rank = Rank.fromRaw(index % ranksPerSuit + 1)

        let card = Card(rank: rank!, suit: suit!)
        deck.append(card)
    }

    return deck
}

let deck = generateDeck()

for card : Card in deck { println("\(card.description)") }

pour utiliser ceci, vous devez vous assurer que les enums Rank et Suit utilisent tous les deux Int pour leurs définitions de type (ex: enum Rank : Int ).

Rank.Ace doit être égal à 1 et le premier Suit cas doit être égal à 0 .

si vous voulez boucle similaire à votre code existant, vous devez toujours faire vos enums Int types de sorte que vous pouvez utiliser Rank.King.toRaw() et similaires.

la documentation D'Apple indique que les enums ne sont pas limités à être 'simplement des valeurs entières', mais peut certainement être si vous souhaitez qu'ils soient.

18
répondu Erik 2014-08-09 03:05:57