Swift: ¿Convertir el valor de enumeración en String?

Dada la siguiente enumeración:

enum Audience {
    case Public
    case Friends
    case Private
}

¿Cómo obtengo la cadena "Public"de la audienceconstante a continuación?

let audience = Audience.Public

No estoy seguro de en qué versión de Swift se agregó esta característica, pero en este momento ( Swift 2.1 ) solo necesita este código:

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

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

Cuando se utilizan cadenas para valores sin formato , el valor implícito para cada caso es el texto del nombre de ese caso .

[...]

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

En el ejemplo anterior, CompassPoint.south tiene un valor bruto implícito de "sur", y así sucesivamente.

Accede al valor sin formato de un caso de enumeración con su propiedad rawValue:

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

Fuente.

La interfaz idiomática para 'obtener una cadena' es usar la CustomStringConvertible interfaz y acceder al descriptiongetter. Define tu 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"
    }
  }
}

En acción:

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

Actualizado : para Swift> = 2.0, reemplazado PrintableporCustomStringConvertible

Nota : El uso CustomStringConvertiblepermite Fooadoptar un tipo sin procesar diferente. Por ejemplo enum Foo : Int, CustomStringConvertible { ... }es posible. Esta libertad puede ser útil.

Por ahora, redefiniré la enumeración como:

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

para que yo pueda hacer:

audience.toRaw() // "Public"

Pero, ¿no es redundante esta nueva definición de enumeración? ¿Puedo mantener la definición de enumeración inicial y hacer algo como:

audience.toString() // "Public"

En Swift 3, puedes usar esto

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

de Swift cómo usar la enumeración para obtener el valor de cadena

Me gusta usar Printablecon Raw Values.

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

    var description: String {
        return self.rawValue
    }
}

Entonces podemos hacer:

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

o

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

Actualizado para el lanzamiento de Xcode 7 GM. Funciona como uno esperaría ahora, ¡gracias 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!"

No podría ser más simple que esto en Swift 2 y el último Xcode 7 (no es necesario especificar el tipo de enumeración, o .rawValue, descriptores, etc.)

Actualizado para Swift 3 y Xcode 8:

    enum Audience {
        case Public
        case Friends
        case Private
    }

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

Un ejemplo rápido 3 y superior si se usa Ints en 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 cualquiera que lea el ejemplo en el capítulo "A Swift Tour" de "The Swift Programming Language" y busque una forma de simplificar el método simpleDescription (), al convertir la enumeración a String, lo String(self)hará:

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

Después de probar algunas formas diferentes, descubrí que si no quieres usar:

let audience = Audience.Public.toRaw()

Todavía puedes archivarlo usando una estructura

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

entonces tu código:

let audience = Audience.Public

Funcionará como se esperaba. No es bonito y hay algunas desventajas porque no estás usando una "enumeración", no puedes usar el acceso directo solo agregando .Private ni funcionará con los casos de cambio.

Hay varias formas de hacer esto. Puede definir una función en la enumeración que devuelve la cadena en función del valor del tipo de enumeración:

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

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

O puedes probar esto:

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

Y para usarlo:

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

A partir de Swift 3.0 puedes

var str = String(describing: Audience.friends)