Kann Swift enums haben mehrere raw-Werte?

Nein, ist ein enum nicht mehrere raw-Werte - es muss sich um einen einzelnen Wert, der Umsetzung der Equatable Protokoll, und wörtlich-Cabrio, wie beschrieben in der Dokumentation.

Ich denke, die beste Vorgehensweise in deinem Fall ist die Verwendung der Fehler-code als roh-Wert und eine Eigenschaft, die, unterstützt durch eine vorkonfigurierte statische Wörterbuch mit dem Fehler-code als Schlüssel und den text als Wert.

Erstellte ich eine Art Simulation dieser (Nicht anders als das, was Marcos Crispino schlug auf seine Antwort). Weit von eine perfekte Lösung, sondern ermöglicht es uns, zu vermeiden, diese fiesen switch-Case-Anweisungen für jede andere Eigenschaft, die wir erhalten wollen.

Der trick ist, verwenden Sie eine Struktur, die als "Eigenschaften/Daten" holder und verwenden Sie es als eine RawValue im enum selbst.

Es hat ein bisschen von überschneidungen, aber es hilft mir bisher sehr gut. Jedes mal, wenn Sie wollen, fügen Sie ein neues enum-Fall, der compiler wird Sie daran erinnern, füllen Sie die zusätzlichen Fall in der rawValue-getter, das sollte Sie daran erinnern, zu aktualisieren init? was würde Sie daran erinnern, um die neue Eigenschaft static auf die struct.

Gist

Code auf das Wesentliche:

enum VehicleType : RawRepresentable {

    struct Vehicle : Equatable {
        let name: String
        let wheels: Int

        static func ==(l: Vehicle, r: Vehicle) -> Bool {
            return l.name == r.name && l.wheels == r.wheels
        }

        static var bike: Vehicle {
            return Vehicle(name: "Bicycle", wheels: 2)
        }

        static var car: Vehicle {
            return Vehicle(name: "Automobile", wheels: 4)
        }

        static var bus: Vehicle {
            return Vehicle(name: "Autobus", wheels: 8)
        }
    }

    typealias RawValue = Vehicle

    case car
    case bus
    case bike

    var rawValue: RawValue {
        switch self {
        case .car:
            return Vehicle.car
        case .bike:
            return Vehicle.bike
        case .bus:
            return Vehicle.bus
        }
    }

    init?(rawValue: RawValue) {
        switch rawValue {
        case Vehicle.bike:
            self = .bike
        case Vehicle.car:
            self = .car
        case Vehicle.bus:
            self = .bus
        default: return nil
        }
    }
}

VehicleType.bike.rawValue.name
VehicleType.bike.rawValue.wheels
VehicleType.car.rawValue.wheels

VehicleType(rawValue: .bike)?.rawValue.name => "Bicycle"
VehicleType(rawValue: .bike)?.rawValue.wheels => 2
VehicleType(rawValue: .car)?.rawValue.name => "Automobile"
VehicleType(rawValue: .car)?.rawValue.wheels => 4
VehicleType(rawValue: .bus)?.rawValue.name => "Autobus"
VehicleType(rawValue: .bus)?.rawValue.wheels => 8

Haben Sie ein paar Optionen. Aber keiner von Ihnen beinhalten raw-Werte. Raw Werte sind einfach nicht das richtige Werkzeug für die Aufgabe.

Option 1 (so-so): die damit Verbundenen Werte

Ich persönlich empfehle dagegen, dass es mehr als einen zugeordneten Wert pro enum-Fall. Die damit verbundenen Werte sollten tot sein, offensichtlich (da Sie nicht über Argumente/- Namen), und Sie haben mehr als eine stark trübt das Wasser.

Das sagte, es ' s etwas die Sprache können Sie tun. Auf diese Weise haben Sie jeweils anders definiert wird, als auch, wenn das war es, was Sie brauchte. Beispiel:

enum ErrorType {
    case teapot(String, Int)
    case skillet(UInt, [CGFloat])
}

Möglichkeit 2 (besser): Tupel! Und berechnete Eigenschaften!

Tupel sind ein großartiges feature von Swift, weil Sie Ihnen die macht der Erstellung von ad-hoc-Arten. Das bedeutet, Sie definieren Sie in-line. Süß!

Wenn die einzelnen Fehlertypen sind zu gehen, um einen code und eine Beschreibung, dann könnten Sie haben eine berechnete info Eigenschaft (hoffentlich mit einem besseren Namen?). Siehe unten:

enum ErrorType {
    case teapot
    case skillet

    var info: (code: Int, description: String) {
        switch self {
        case .teapot:
            return (418, "Hear me shout!")
        case .skillet:
            return (326, "I'm big and heavy.")
        }
    }
}

Aufruf dieser würde mich viel einfacher, da könnten Sie schmackhaft Punkt-syntax:

let errorCode = myErrorType.info.code

In modernen Versionen von Swift ist es möglich, den string-Wert eines enum-case-Bezeichnung, auch ohne, dass enum erklärt wird, mit einer : String rawValue.

So bekommen Sie den Namen der enumeration value in Swift?

So ist es nicht mehr eine Notwendigkeit, Sie zu definieren und pflegen eine Komfort-Funktion, die schaltet auf jeden Fall um einen string-literal. Darüber hinaus funktioniert dies automatisch für jede enum, auch wenn keine raw-Wert-Typ angegeben.

Wenigstens dies ermöglicht haben "mehrere raw-Werte", indem er sowohl eine echte : Int rawValue als auch die Zeichenkette für den Fall label.

Möglich umgehen kann assoziieren benutzerdefinierter Funktionen mit enum

 enum ToolbarType : String{
        case Case = "Case", View="View", Information="Information"
        static let allValues = [Case, View, Information]

        func ordinal() -> Int{
            return ToolbarType.allValues.index(of: self)!
        }
 }

Kann verwendet werden, als

 for item in ToolbarType.allValues {
        print("\(item.rawValue): \(item.ordinal())")
 }

Ausgabe

Case: 0
View: 1
Information: 2

Möglicherweise können Sie zusätzliche Funktionen zuordnen enum-Typ für verschiedene Werte