在 Swift 中，是否可以将字符串转换为枚举？

Question

如果我有一个枚举，情况为 a,b,c,d 是否可以将字符串“a”转换为枚举？

Answer 1

当然。 枚举可以具有原始值。 引用文档：

原始值可以是字符串、字符或任何整数或浮点数类型

— 摘自：Apple Inc. “The Swift Programming Language”。 电子书。 https://itun.es/us/jEUH0.l ,

所以你可以使用这样的代码：

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

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

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

注意：您不需要在每个案例之后写上 = "one" 等。 默认字符串值与案例名称相同，因此调用.rawValue只会返回一个字符串

编辑

如果您需要字符串值包含不能作为 case 值一部分的空格之类的东西，那么您需要显式设置字符串。 所以，

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

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

给

anEnum = "一"

但是，如果您希望case one显示“值一”，则需要提供字符串值：

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

Answer 2

所有你需要的是：

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

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

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

Answer 3

在 Swift 4.2 中，CaseIterable 协议可用于带有 rawValues 的枚举，但字符串应与枚举 case 标签匹配：

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

用法：

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

Answer 4

如果使用 Int 类型的枚举，您可以这样做：

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

并使用：

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

Answer 5

斯威夫特 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
    }
}

Answer 6

借鉴 djruss70 的答案以创建高度通用的解决方案：

extension CaseIterable {
    static func from(string: String) -> Self? {
        return Self.allCases.first { string == "\($0)" }
    }
    func toString() -> String { "\(self)" }
}

用法：

enum Chassis: CaseIterable {
    case pieridae, oovidae
}

let chassis: Chassis = Chassis.from(string: "oovidae")!
let string: String = chassis.toString()

注意：如果枚举被声明为@objc，这将很不幸地不起作用。 据我所知，从 Swift 5.3 开始，除了蛮力解决方案（switch 语句）之外，没有办法让它与 @objc 枚举一起使用。

如果有人碰巧知道为@objc enums 做这项工作的方法，我会对答案非常感兴趣。

Answer 7

扩展 Duncan C 的回答

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

Answer 8

对于 Int 枚举及其字符串表示，我声明枚举如下：

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

用法：

order.orderState = OrderState.waiting.rawValue

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

Answer 9

我用过这个：

public enum Currency: CaseIterable, Codable {
    case AFN = 971 // Afghani (minor=2)
    case DZD = 012 // Algerian Dinar (minor=2)

...

    private static var cachedLookup: [String: Currency] = [:]
    
    init?(string: String) {
        if Self.cachedLookup.isEmpty {
            Self.cachedLookup = Dictionary(uniqueKeysWithValues: Self.allCases.map { ("\($0)", $0) })
        }
        
        if let currency = Self.cachedLookup[string] {
            self = currency
            return
        } else {
            return nil
        }
    }
}

Answer 10

我发现其他答案使这种方式变得更加复杂，而不是需要。 这是一个快速简洁的示例。

enum Gender: String {
    case male, female, unspecified
}

简单枚举，注意我在枚举本身中添加了“:String”来将类型声明为字符串。

现在你所要做的就是：

let example: Gender = Gender(rawValue: "male")

就是这样，'example' 现在是 Gender 类型的枚举，其值为 of.male

在 Swift 4+ 中，您几乎不需要做任何其他事情。