Swift: Converter valor de enum em String?

Dado o seguinte enum:

enum Audience {
    case Public
    case Friends
    case Private
}

Como obtenho a string "Public"da audienceconstante abaixo?

let audience = Audience.Public

Não sabe em qual versão Swift esse recurso foi adicionado, mas agora ( Swift 2.1 ) você só precisa deste código:

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

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

Quando cadeias são usadas para valores brutos, o valor implícito para cada caso é o texto do nome desse caso .

[...]

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

No exemplo acima, CompassPoint.south tem um valor bruto implícito de "sul" e assim por diante.

Você acessa o valor bruto de um caso de enumeração com sua propriedade rawValue:

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

Fonte.

A interface idiomática para 'obter uma String' é usar a CustomStringConvertible interface e acessar o descriptiongetter. Defina seu enumcomo:

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

Em ação:

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

Atualizado : para Swift> = 2.0, substituído PrintableporCustomStringConvertible

Nota : Usar CustomStringConvertiblepermite Fooadotar um tipo bruto diferente. Por exemplo, enum Foo : Int, CustomStringConvertible { ... }é possível. Essa liberdade pode ser útil.

Por enquanto, redefinirei a enum como:

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

para que eu possa fazer:

audience.toRaw() // "Public"

Mas, essa nova definição de enum não é redundante? Posso manter a definição inicial de enum e fazer algo como:

audience.toString() // "Public"

No swift 3, você pode usar este

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

do Swift como usar enum para obter o valor da string

Eu gosto de usar Printablecom Raw Values.

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

    var description: String {
        return self.rawValue
    }
}

Então nós podemos fazer:

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

ou

println("The value of Public is \(Audience.Public)") 
// Prints "The value of Public is Public"

Atualizado para o lançamento do Xcode 7 GM. Funciona como seria de esperar agora - obrigado Apple!

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!"

Não poderia ser mais simples do que isso no Swift 2 e no Xcode 7 mais recente (não há necessidade de especificar o tipo de enum ou .rawValue, descritores etc ...)

Atualizado para Swift 3 e Xcode 8:

    enum Audience {
        case Public
        case Friends
        case Private
    }

    let audience: Audience = .Public  // or, let audience = Audience.Public
    print(audience) // "Public"

Um exemplo rápido 3 e acima se estiver usando Ints no Enum

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

Para quem lê o exemplo no capítulo "Um tour Swift" de "A linguagem de programação Swift" e procura uma maneira de simplificar o método simpleDescription (), a conversão da enum em String ao String(self)fazer isso:

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

Depois de tentar algumas maneiras diferentes, descobri que se você não quiser usar:

let audience = Audience.Public.toRaw()

Você ainda pode arquivá-lo usando uma estrutura

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

então seu código:

let audience = Audience.Public

funcionará como esperado. Não é bonito e há algumas desvantagens porque você não está usando uma "enumeração", não é possível usar o atalho apenas adicionando .Private nem funcionará com casos de opção.

Existem várias maneiras de fazer isso. Você pode definir uma função no enum que retorne a string com base no valor do tipo de enum:

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

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

Ou você pode tentar o seguinte:

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

E para usá-lo:

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

A partir do Swift 3.0, você pode

var str = String(describing: Audience.friends)