Eine Methode hinzufügen, Karte, wird eine vollständige deck von Karten, mit einer Karte von jeder Kombination von Rang und Anzug

Einem robusten code Antwort wird nicht auf die Verwendung der tatsächlichen Werte (dh, .Pik) aus den Aufzählungen bei der Erstellung der deck, z.B., wenn ein "spaßvogel" ist später Hinzugefügt, um den Rang enumeration (irgendwo in der Aufzählung), die deck-generation-Funktion sollte weiterhin ohne änderung funktionieren.

Design-Fragen (was zurückgeben?, sollte das deck-generation die Funktion der Karte?) sind nicht wirklich relevant für dieses tutorial, aber es ist wahrscheinlich, dass eine Deck-Klasse wäre besser, wenn jeder ernsthafte Funktionalität ist gebaut-weitere (z.B. shuffle). Also für jetzt, die Rückgabe eines Arrays aus einer Funktion in der Karten-Struktur ist alles, was erforderlich ist.

Den folgenden code (so weit wie nur möglich mit dem, was beschrieben wurde bis zu diesem Zeitpunkt im tutorial) definiert eine Funktion in der Karten-Struktur durchläuft, der Anzug und Rang Aufzählungen, ohne zu wissen, eine der enumeration-Werte und gibt ein Array zurück:

static func deck() -> [Card] {
    var deck = [Card]()
    var suitCount = 1
    while let suit = Suit(rawValue: suitCount) {
        var rankCount = 1
        while let rank = Rank(rawValue: rankCount) {
            deck.append(Card(rank: rank, suit: suit))
            rankCount += 1
        }
        suitCount += 1
    }
    return deck
}

Aufrufen mit:

let deck = Card.deck()
var card3 = deck[3].simpleDescription()

Kopieren Sie die Funktion in der Karten-Struktur und versuchen Sie, die Werte zu enums. Beachten Sie Folgendes:

• wie die Anzahl der Zeiten, die Schleifen ausgeführt werden, änderungen, die beim hinzufügen zu den enums
• dass die beiden enum-Zähler bei 1 beginnen (wenn nicht anders angegeben, in der Aufzählung der ersten raw-Wert ist einer)
• unbekannter array-Indizes bei 0 beginnen (z.B., deck[3] ist eigentlich der Pik 4)

Einer for-Schleife ist der Weg zu gehen. Ich machte ein paar Anpassungen in der base code. Zuerst, ich habe eine Art zu Ihrem Anzug enum.

enum Suit : Int

Dann habe ich eine Klasse namens Deck, die verantwortlich ist für ein deck von Karten.

class Deck {
    var cards:Card[]

    init() {
        self.cards = Array<Card>()
    }

    func createDeck() {
        for suit in 0...Suit.Clubs.toRaw() {
            for rank in 1...Rank.King.toRaw() {
                self.cards += Card(rank: Rank.fromRaw(rank)!, suit: Suit.fromRaw(suit)!)
            }
        }
    }
}

func createDeck() Schleifen über alle möglichen Karten und fügt Sie deinem deck hinzu.

Zunächst werde ich die Bewältigung der einfachsten Frage: Wo setzen Sie den code, der schafft den vollen deck ist bis zu Ihnen, aber ich würde dir raten nicht um es in Card, sondern erstellen Sie eine Deck Klasse und bieten eine Komfort-Initialisierung es zu tun gibt.

Dieser sagte, lasst uns fortfahren mit dem plan, indem es der Card Klasse. Leider gibt es keine Möglichkeit, nur Schleife über alle möglichen Werte einer Enum-so, wie Sie hoffen würde (obwohl ich würde gerne irren!), aber Sie kann hierzu:

let first_card = Rank.Ace.toRaw() //== 1
let last_card = Rank.King.toRaw() //== 13

for raw_rank in first_card...last_card {
    let rank = Rank.fromRaw(raw_rank)!
}

Lassen Sie uns gehen durch diese. Enum ordnet eine zugrunde liegende Wert, auf jeden Fall, und durch das schreiben case Ace = 1 Sie es einrichten zu starten zählen von 1 (statt 0, Standard). Die API zur Verfügung gestellt, die durch eine Enum für den Zugriff auf den zugrunde liegenden Wert ein toRaw() - Methode für jede Enum-Fall (Das Enum selbst auch bietet es in form von Rank.toRaw(Rank.Ace).

Können Sie konvertieren zurück aus dem raw Wert mit dem passenden Namen fromRaw() Methode (so Rank.fromRaw(1) würde uns Ass), aber es gibt eine Einschränkung: Es gibt ein optionales. Der Rückgabetyp ist Rank?, nicht Rank. Um Zugriff auf den Wert, den Sie brauchen, um entweder check für null, oder zwingen Sie es Auspacken.

Überprüfung auf nil:

if let rank = Rank.fromRaw(1) {
    //Do stuff with rank, which is now a plain old Rank
}
else {
    //handle nil
}

Kraft packen:

var rank: Rank = Rank.fromRaw(1)!

Also zur Beantwortung Ihrer Frage zu den Schleifen: ja, das ist der Weg, es zu tun =P, und nochmal ja über das array, wenn das eine design-Entscheidung. Es macht einfach so viel Sinn zu erschaffen, eine Deck - Klasse und Rendite, statt.

Fügen wir die Methode mit eine Erweiterung. Erweiterungen ermöglichen das hinzufügen von Funktionalität zu einem bestehenden Typ. Sie können erstellen eine Erweiterung auf eine Klasse, ein enum, oder sogar einen primitiven Typ. so ziemlich alles.

extension Card {

    func createFullDeck() -> Card[] {
        var deck: Array<Card> = []
        for raw_rank in Rank.Ace.toRaw()...Rank.King.toRaw() {
            deck += [
                Card(rank:Rank.fromRaw(raw_rank)!, suit:.Spades),
                Card(rank:Rank.fromRaw(raw_rank)!, suit:.Hearts),
                Card(rank:Rank.fromRaw(raw_rank)!, suit:.Diamonds),
                Card(rank:Rank.fromRaw(raw_rank)!, suit:.Clubs),
            ]
        }
        return deck
    }

}

Überraschend, niemand hatte ein Gebot auf eine funktionelle Umsetzung. Hier geht:

extension Array {
  func flatten<T>() -> T[] {
    let xs = (self as Any) as Array<Array<T>>
    return xs.reduce(T[]()) { (x, acc) in x + acc }
  }
}

extension Card {
  static func fullDeck() -> Card[] {
    let rawRanks = Array(Rank.Ace.toRaw()...Rank.King.toRaw())
    let suits: Suit[] = [.Spades, .Hearts, .Diamonds, .Clubs]
    return (rawRanks.map {
      rawRank in suits.map {
        suit in Card(rank: Rank.fromRaw(rawRank)!, suit: suit)
        }
      }).flatten()
  }
}

Ich habe gerade angefangen zu lernen, dass Swift auch, und der hatte das gleiche problem. Auch ich dachte, es war ziemlich seltsam, dass das experiment war die Erstellung einer Methode im inneren der Karte Struktur zu erstellen, eine vollständige deck von Karten.

Nach einem Blick auf diese Antworten, und Lesen Sie die offizielle Apple - "The Swift Programming Language (Swift 2.1)" - tour, ich löste es so:

struct Card {
    var rank: Rank
    var suit: Suit

    func simpleDescription() -> String {
        return "The \(rank.simpleDescription()) of \(suit.simpleDescription())"
    }

    func createDeck() -> [Card] {
        let suits = [Suit.Spades, Suit.Hearts, Suit.Clubs, Suit.Diamonds]
        var deck = [Card]()

        for theSuit in suits {
            for theRank in Rank.Ace.rawValue...Rank.King.rawValue {
                deck.append(Card(rank: Rank(rawValue: theRank)!, suit: theSuit))
            }
        }

        return deck
    }
}

let aceOfHearts = Card(rank: .Ace, suit: .Hearts)
let deck = aceOfHearts.createDeck()

for card in deck {
    print("\(card.rank) of \(card.suit)")
}

Da alle Beispiele oben sind unerlässlich in der Natur und Swift ist gebaut mit die funktionale Programmierung im Verstand, ich nahm einen mehr funktionalen Ansatz zur Lösung des Problems. Hier ist mein vollständiger code:

Mein Rang enum (definieren ein array mit allen Werten, weil es nicht möglich ist, Durchlaufen alle Werte eines enum aus irgendeinem Grund)

enum Rank: Int, CustomStringConvertible {

    case ace = 1
    case two, three, four, five, six, seven, eight, nine, ten
    case jack, queen, king

    static let allRanks = [ace, two, three, four, five, six, seven, eight, nine, ten, jack, queen, king]

    var description: String {
        switch self {
        case .ace:
            return "ace"
        case .jack:
            return "jack"
        case .queen:
            return "queen"
        case .king:
            return "king"
        default:
            return String(self.rawValue)
        }
    }
}

Farbe enum (Hinzugefügt ähnlich wie array-Typ)

enum Suit: String, CustomStringConvertible  {

    case spades = "♠︎"
    case hearts = "♥︎"
    case diamonds = "♦︎"
    case clubs = "♣︎"

    static let allSuits = [spades, hearts, diamonds, clubs]

    var description: String {
        switch self {
        default:
            return rawValue
        }
    }

}

...und schließlich: die Karte

struct Card: CustomStringConvertible {
    var rank: Rank
    var suit: Suit

    var description: String {
        return "\(rank)\(suit)"
    }

    static func createDeckOfCards() -> [Card] {
        return Suit.allSuits.reduce([]) {
            deck, suit in deck + Rank.allRanks.reduce([]) {
                cardsInSuit, rank in cardsInSuit + [Card(rank: rank, suit: suit)]
            }
        }
    }
}

print(Card.createDeckOfCards())