String Swift：是否将枚举值转换为字符串？

给定以下枚举：

enum Audience {
    case Public
    case Friends
    case Private
}

如何从下面的

受众

常量中获取字符串

“Public”

let audience = Audience.Public

---

现在，我将重新定义枚举为：

enum Audience: String {
    case Public = "Public"
    case Friends = "Friends"
    case Private = "Private"
}

因此，我可以：

audience.toRaw() // "Public"

但是，这个新的枚举定义不是多余的吗？我是否可以保留初始枚举定义并执行以下操作：

audience.toString() // "Public"

---

“获取字符串”的惯用界面是使用

CustomStringConvertible

界面并访问

description

getter。将您的

枚举定义为：

enum Foo : CustomStringConvertible {
  case Bing
  case Bang
  case Boom
  
  var description : String { 
    switch self {
    // Use Internationalization, as appropriate.
    case .Bing: return "Bing"
    case .Bang: return "Bang"
    case .Boom: return "Boom"
    }
  }
}

在行动中：

 > let foo = Foo.Bing
foo: Foo = Bing
 > println ("String for 'foo' is \(foo)"
String for 'foo' is Bing

更新：对于Swift>=2.0，将
可打印
替换为
CustomStringConvertible

注意：使用
CustomStringConvertible
允许
Foo
采用不同的原始类型。例如
enum Foo:Int，CustomStringConvertible{…}
是可能的。这种自由是有用的。
尝试了几种不同的方法后，我发现如果您不想使用：

let audience = Audience.Public.toRaw()

您仍然可以使用结构对其进行归档

struct Audience {
   static let Public  = "Public"
   static let Friends = "Friends"
   static let Private = "Private"
}

然后您的代码：

let audience = Audience.Public

将按预期工作。它不美观，也有一些缺点，因为你不使用“枚举”，你不能只使用快捷方式添加。Private也不适用于开关盒。
有多种方法可以做到这一点。您可以在枚举中定义一个函数，该函数根据枚举类型的值返回字符串：

enum Audience{
    ...
func toString()->String{
  var a:String

  switch self{
   case .Public:
    a="Public"
   case .Friends:
    a="Friends"
   ...
 }
 return a
}

或者你可以试试这个：

enum Audience:String{
   case Public="Public"
   case Friends="Friends"
   case Private="Private"
}

使用它：

var a:Audience=Audience.Public
println(a.toRaw())

我喜欢将
可打印的
与
原始值一起使用

enum Audience: String, Printable {
    case Public = "Public"
    case Friends = "Friends"
    case Private = "Private"

    var description: String {
        return self.rawValue
    }
}

然后我们可以做：

let audience = Audience.Public.description // audience = "Public"

或

为Xcode 7 GM的发布进行了更新。它现在可以正常工作了——谢谢苹果

enum Rank:Int {
    case Ace = 1, Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten, Jack, Queen, King
}

let r = Rank.Ace

print(r)               // prints "Ace"
print("Rank: \(r)!")   // prints "Rank: Ace!"

不确定在哪个Swift版本中添加了此功能，但现在（Swift 2.1）您只需要以下代码：

enum Audience : String {
    case public
    case friends
    case private
}

let audience = Audience.public.rawValue // "public"

当字符串用于原始值时，每种情况的隐式值
是该案例名称的文本

[……]

enum CompassPoint : String {
    case north, south, east, west
}

在上面的示例中，CompassPoint.south的隐式原始值为
“南方”，等等

您可以使用枚举案例的原始值访问其原始值
财产：

let sunsetDirection = CompassPoint.west.rawValue
// sunsetDirection is "west"


在Swift 2和最新的Xcode 7中，它再简单不过了（不需要指定枚举类型、或.rawValue、描述符等）

针对Swift 3和Xcode 8进行了更新：

对于阅读“Swift编程语言”的“Swift Tour”一章中的示例并寻找简化simpleDescription（）方法的方法的任何人，通过执行
String（self）
将枚举本身转换为字符串即可：

enum Rank: Int
{
    case Ace = 1 //required otherwise Ace will be 0
    case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten
    case Jack, Queen, King
    func simpleDescription() -> String {
        switch self {
            case .Ace, .Jack, .Queen, .King:
                return String(self).lowercaseString
            default:
                return String(self.rawValue)
        }
     }
 }

在swift 3中，您可以使用

var enumValue = Customer.Physics
var str = String(describing: enumValue)

如果在枚举中使用Ints，请参见swift 3及以上示例

public enum ECategory : Int{
        case Attraction=0, FP, Food, Restroom, Popcorn, Shop, Service, None;
        var description: String {
            return String(describing: self)
        }
    }

let category = ECategory.Attraction
let categoryName = category.description //string Attraction

从Swift 3.0开始，您可以

var str = String(describing: Audience.friends)

使用Ruby方式

var public: String = "\(Audience.Public)"

还有一条路

public enum HTTP{
case get
case put
case delete
case patch
var value: String? {
return String(describing: self)
}

如果需要使用静态字符串作为枚举值，则指南会提供友好的帮助：

class EncyclopediaOfCats {
    struct Constants {
        static var playHideAndSeek: String { "Play hide-and-seek" }
        static var eat: String { "Eats" }
        static var sleep: String { "Sleep" }
        static var beCute: String { "Be cute" }
    }
}

enum CatLife {
    case playHideAndSeek
    case eat
    case sleep
    case beCute

    typealias RawValue = String
    
    var rawValue: String {
        switch self {
        case .playHideAndSeek:
            return EncyclopediaOfCats.Constants.playHideAndSeek
        case .eat:
            return EncyclopediaOfCats.Constants.eat
        case .sleep:
            return EncyclopediaOfCats.Constants.sleep
        case .beCute:
            return EncyclopediaOfCats.Constants.beCute
        }
    }
    
    init?(rawValue: CatLife.RawValue) {
        switch rawValue {
        case EncyclopediaOfCats.Constants.playHideAndSeek:
            self = .playHideAndSeek
        case EncyclopediaOfCats.Constants.eat:
            self = .eat
        case EncyclopediaOfCats.Constants.sleep:
            self = .sleep
        case EncyclopediaOfCats.Constants.beCute:
            self = .beCute
        default:
            self = .playHideAndSeek
        }
    }
}

我同意以上所有答案，但在您的enum中，无法定义private和public案例，因为它们是默认关键字。我的答案中包含了CaseIterable，如果您需要循环，它可能会帮助您获取所有案例

enum Audience: String, CaseIterable {
case publicAudience
case friends
case privateAudience

var description: String {
    switch self {
    case .publicAudience: return "Public"
    case .friends: return "Friends"
    case .privateAudience: return "Private"
    }
}

static var allAudience: [String] {
    return Audience { $0.rawValue }
}

}
请检查这个答案，它可能会给你一些关于如何实现这一目标的想法：在Swift 2和xcode7中，你不需要对代码做任何更改，只需使用
print（\（观众）”）
我讨厌Swift ecoscape现在充斥着这样非常过时的答案。从XCode8.2/Swift3开始，它就像
String（description:yourEnumValue）
@TravisGriggs一样简单。它不适用于Xcode 11.4。创建println字符串的另一种较短方法的任何长的可能的副本是：“String for'foo'is（foo）”@JohnM.P.Knox不要忘记“String for'foo'is\（foo）”中的反斜杠。编辑好的，是编辑把它处理掉了，我必须输入其中的两个，以便它向上显示
CustomStringConvertible
中的要点是什么？如果没有它，它也可以正常工作？
CustomStringConvertible
允许/要求您定义
description
，它让您决定每个枚举案例使用哪个字符串-这对于国际化非常重要当然也可能是代码可读性。如果您不关心这些，那么您可以使用'enum Foo:String{/*…*/}`这是正确的答案，如果您的enum不是字符串，或者您需要一个不同的字符串，然后是原始值@denis631I比选择的答案更喜欢这种方式，因为我可以做
受众（rawValue:“Friends”）
从Xcode 7 Beta 3开始，您可以只写答案，但不需要
=字符串，因为如果您不提供任何原始值，它会自动获得原始值（案例名称）。而不是.toString（）现在在Swift 1.2中使用.rawValues，您可以在Swift 2.0中使用：println（academy.Friends.rawValue），符合
CustomStringConvertible
的要求，在这种情况下实际上只允许使用
print（r）
。在Xcode 7 beta 4中，反射（）似乎已被禁用，以支持镜像（反射：x）。但是，返回的对象具有不同的结构。请更新答案看起来很整洁。我想知道对于这一特殊情况，什么是最佳做法。我更喜欢使用struct语法，因为它很简单，但是使用struct而不是enum似乎不正确，或者可能只是我自己？好的，没有什么可以阻止你在其他地方声明常量变量，这次你只是把它添加到一个结构中，这样它就有组织了。思想？确切地说，它是一个恒定的变量，但更有组织性。正如我之前所说，唯一的问题是“开关盒”和快捷方式“.Private”。如果您是从头开始构建应用程序，请尝试使用“enum”，仅当“enum”由于某种原因不满足您的代码时才使用structs。我个人建议避免常量变量，而总是使用结构。我将其用于默认键。我没有记住应用程序中的默认键，而是将这些键转储到一个结构中并从结构中提取。与我的Int-backed枚举完美配合只是一个观察：这对自建枚举有效，但对HK之类的对象不起作用
class EncyclopediaOfCats {
    struct Constants {
        static var playHideAndSeek: String { "Play hide-and-seek" }
        static var eat: String { "Eats" }
        static var sleep: String { "Sleep" }
        static var beCute: String { "Be cute" }
    }
}

enum CatLife {
    case playHideAndSeek
    case eat
    case sleep
    case beCute

    typealias RawValue = String
    
    var rawValue: String {
        switch self {
        case .playHideAndSeek:
            return EncyclopediaOfCats.Constants.playHideAndSeek
        case .eat:
            return EncyclopediaOfCats.Constants.eat
        case .sleep:
            return EncyclopediaOfCats.Constants.sleep
        case .beCute:
            return EncyclopediaOfCats.Constants.beCute
        }
    }
    
    init?(rawValue: CatLife.RawValue) {
        switch rawValue {
        case EncyclopediaOfCats.Constants.playHideAndSeek:
            self = .playHideAndSeek
        case EncyclopediaOfCats.Constants.eat:
            self = .eat
        case EncyclopediaOfCats.Constants.sleep:
            self = .sleep
        case EncyclopediaOfCats.Constants.beCute:
            self = .beCute
        default:
            self = .playHideAndSeek
        }
    }
}

enum Audience: String, CaseIterable {
case publicAudience
case friends
case privateAudience

var description: String {
    switch self {
    case .publicAudience: return "Public"
    case .friends: return "Friends"
    case .privateAudience: return "Private"
    }
}

static var allAudience: [String] {
    return Audience { $0.rawValue }
}