Ist es in Swift möglich, einen String in eine Aufzählung umzuwandeln?

Wenn ich eine Aufzählung mit den Fällen a, b, c, d habe, kann ich dann die Zeichenfolge "a" als Aufzählung verwenden?

Sicher. Aufzählungen können einen Rohwert haben. So zitieren Sie die Dokumente:

Rohwerte können Zeichenfolgen, Zeichen oder beliebige Ganzzahl- oder Gleitkommazahlentypen sein

- Auszug aus: Apple Inc. "The Swift Programming Language". iBooks. https://itun.es/us/jEUH0.l ,

Sie können also folgenden Code verwenden:

enum StringEnum: String 
{
  case one = "one"
  case two = "two"
  case three = "three"
}

let anEnum = StringEnum(rawValue: "one")!

print("anEnum = \"\(anEnum.rawValue)\"")

Hinweis: Sie müssen nicht nach jedem Fall = "eins" usw. schreiben. Die Standardwerte für Zeichenfolgen entsprechen den Fallnamen, sodass beim Aufrufen .rawValuenur eine Zeichenfolge zurückgegeben wird

BEARBEITEN

Wenn der Zeichenfolgenwert beispielsweise Leerzeichen enthalten soll, die als Teil eines Fallwerts nicht gültig sind, müssen Sie die Zeichenfolge explizit festlegen. So,

enum StringEnum: String 
{
  case one
  case two
  case three
}

let anEnum = StringEnum.one
print("anEnum = \"\(anEnum)\"")

gibt

anEnum = "eins"

Wenn Sie case onejedoch "Wert eins" anzeigen möchten , müssen Sie die folgenden Zeichenfolgenwerte angeben:

enum StringEnum: String 
{
  case one   = "value one"
  case two   = "value two"
  case three = "value three"
}

Alles was Sie brauchen ist:

enum Foo: String {
   case a, b, c, d
}

let a = Foo(rawValue: "a")
assert(a == Foo.a)

let 💩 = Foo(rawValue: "💩")
assert(💩 == nil)

In Swift 4.2 kann das CaseIterable-Protokoll für eine Aufzählung mit rawValues ​​verwendet werden, die Zeichenfolge sollte jedoch mit den Aufzählungszeichen übereinstimmen:

enum MyCode : String, CaseIterable {

    case one   = "uno"
    case two   = "dos"
    case three = "tres"

    static func withLabel(_ label: String) -> MyCode? {
        return self.allCases.first{ "\($0)" == label }
    }
}

Verwendung:

print(MyCode.withLabel("one")) // Optional(MyCode.one)
print(MyCode(rawValue: "uno"))  // Optional(MyCode.one)

Bei einer Aufzählung mit Int-Typ können Sie dies folgendermaßen tun:

enum MenuItem: Int {
    case One = 0, Two, Three, Four, Five //... as much as needs

    static func enumFromString(string:String) -> MenuItem? {
        var i = 0
        while let item = MenuItem(rawValue: i) {
            if String(item) == string { return item }
            i += 1
        }
        return nil
    }
}

Und benutze:

let string = "Two"
if let item = MenuItem.enumFromString(string) {
    //in this case item = 1 
    //your code
} 

Die Antwort von Duncan C erweitern

extension StringEnum: StringLiteralConvertible {

    init(stringLiteral value: String){
        self.init(rawValue: value)!
    }

    init(extendedGraphemeClusterLiteral value: String) {
        self.init(stringLiteral: value)
    }

    init(unicodeScalarLiteral value: String) {
        self.init(stringLiteral: value)
    }
}

Swift 4.2:

public enum PaymentPlatform: String, CaseIterable {
    case visa = "Visa card"
    case masterCard = "Master card"
    case cod = "Cod"

    var nameEnum: String {
        return Mirror(reflecting: self).children.first?.label ?? String(describing: self)
    }

    func byName(name: String) -> PaymentPlatform {
        return PaymentPlatform.allCases.first(where: {$0.nameEnum.elementsEqual(name)}) ?? .cod
    }
}

Für Int enum und ihre String-Darstellung deklariere ich enum wie folgt:

enum OrderState: Int16, CustomStringConvertible {

    case waiting = 1
    case inKitchen = 2
    case ready = 3

    var description: String {
        switch self {
        case .waiting:
            return "Waiting"
        case .inKitchen:
            return "InKitchen"
        case .ready:
            return "Ready"
        }
    }

    static func initialize(stringValue: String)-> OrderState? {
        switch stringValue {
        case OrderState.waiting.description:
            return OrderState.waiting
        case OrderState.inKitchen.description:
            return OrderState.inKitchen
        case OrderState.ready.description:
            return OrderState.ready

        default:
            return nil
        }
    }
}

Verwendung:

order.orderState = OrderState.waiting.rawValue

let orderState = OrderState.init(rawValue: order.orderState)
let orderStateStr = orderState?.description ?? ""
print("orderStateStr = \(orderStateStr)")