Wie nummeriert man einen Aufzählungstyp mit String-Typ?

Question

enum Suit: String {
    case spades = ""
    case hearts = ""
    case diamonds = ""
    case clubs = ""
}

Zum Beispiel, wie kann ich so etwas machen:

for suit in Suit {
    // Bearbeite etwas mit dem Anzug
    print(suit.rawValue)
}

Ergebnisbeispiel:

Answer 1

Sie können versuchen, so aufzuzählen

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]

Answer 2

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
    }
}

Wie wäre es damit?

Answer 3

In Swift 3, wenn das zugrunde liegende Enum rawValue hat, können Sie das Strideable-Protokoll implementieren. Die Vorteile sind, dass keine Arrays von Werten erstellt werden wie bei einigen anderen Vorschlägen und dass die standardmäßige Swift-"for in"-Schleife funktioniert, was eine schöne Syntax ergibt.

// "Int" zum Abrufen von rawValue und Strideable, damit wir iterieren können
enum MyColorEnum: Int, Strideable {
    case Rot
    case Grün
    case Blau
    case Schwarz

    // von Strideable benötigt
    typealias Stride = Int

    func advanced(by n: Stride) -> MyColorEnum {
        var next = self.rawValue + n
        if next > MyColorEnum.Schwarz.rawValue {
            next = MyColorEnum.Schwarz.rawValue
        }
        return MyColorEnum(rawValue: next)!
    }

    func distance(to other: MyColorEnum) -> Int {
        return other.rawValue - self.rawValue
    }

    // nur für die Ausgabe
    func simpleDescription() -> String {
        switch self {
        case .Rot: return "Rot"
        case .Grün: return "Grün"
        case .Blau: return "Blau"
        case .Schwarz: return "Schwarz"
        }
    }
}

// so verwenden Sie es:
for i in MyColorEnum.Rot ... MyColorEnum.Schwarz {
    print("ENUM: \(i)")
}

Answer 4

Entschuldigung, meine Antwort war spezifisch für die Art und Weise, wie ich diesen Beitrag in dem, was ich tun musste, verwendet habe. Für diejenigen, die auf diese Frage stoßen und nach einem Weg suchen, ein Gehäuse innerhalb eines Enums zu finden, ist dies der Weg (neu in Swift 2):

Bearbeiten: Kleinbuchstaben camelCase ist jetzt der Standard für Swift 3 Enum-Werte

// Aus Äpfel Dokumentation: Wenn der Rohwerttyp als String festgelegt ist und Sie den Fällen nicht explizit Werte zuweisen, wird jedem nicht zugewiesenen Fall implizit ein String mit demselben Text wie der Name dieses Falls zugewiesen.

enum Thema: String
    {
    case weiß, blau, grün, lavendel, grau
    }

func ladeThema(thema: String)
    {
    // Prüft den String gegen den Rohwert jedes Enum-Werts (beachten Sie, dass die Prüfung zu einem nil-Wert führen könnte, da es optional ist, weshalb wir den if/let-Block einführen
    if let testThema = Thema(rawValue: thema)
        {
        // testTheme hat an dieser Stelle garantiert einen Enum-Wert
        self.someOtherFunction(testThema)
        }
    }

Für diejenigen, die sich darüber wundern, wie man in einem Enum aufzählt, sind die Antworten auf dieser Seite, die eine static var/let enthalten, die ein Array aller Enum-Werte enthält, korrekt. Der neueste Beispielcode von Apple für tvOS enthält genau diese Technik.

Das gesagt, sollten sie einen bequemeren Mechanismus in die Sprache integrieren (Apple, hört ihr zu?)!

Answer 5

Diese Lösung findet das richtige Gleichgewicht zwischen Lesbarkeit und Wartbarkeit.

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()