Swift: converti il ​​valore enum in String?

Dato il seguente enum:

enum Audience {
    case Public
    case Friends
    case Private
}

Come ottengo la stringa "Public"dalla audiencecostante sotto?

let audience = Audience.Public

Non sei sicuro di quale versione di Swift sia stata aggiunta questa funzionalità, ma al momento ( Swift 2.1 ) hai solo bisogno di questo codice:

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

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

Quando le stringhe vengono utilizzate per valori non elaborati, il valore implicito per ciascun caso è il testo del nome di quel caso .

[...]

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

Nell'esempio sopra, CompassPoint.south ha un valore grezzo implicito di "sud" e così via.

Si accede al valore non elaborato di un caso di enumerazione con la sua proprietà rawValue:

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

Fonte.

L'interfaccia idiomatica per "ottenere una stringa" è usare l' CustomStringConvertible interfaccia e accedere al descriptiongetter. Definisci il tuo enumcome:

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

In azione:

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

Aggiornato : per Swift> = 2.0, sostituito PrintableconCustomStringConvertible

Nota : l'utilizzo CustomStringConvertibleconsente Foodi adottare un diverso tipo di raw. Ad esempio enum Foo : Int, CustomStringConvertible { ... }è possibile. Questa libertà può essere utile.

Per ora, ridefinirò l'enum come:

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

in modo che io possa fare:

audience.toRaw() // "Public"

Ma questa nuova definizione di enum non è ridondante? Posso mantenere la definizione di enum iniziale e fare qualcosa del tipo:

audience.toString() // "Public"

In swift 3, puoi usare questo

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

da Swift come usare enum per ottenere il valore di stringa

Mi piace usare Printablecon Raw Values.

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

    var description: String {
        return self.rawValue
    }
}

Quindi possiamo fare:

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

o

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

Aggiornato per il rilascio di Xcode 7 GM. Funziona come uno spererebbe ora - grazie 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!"

Non potrebbe essere più semplice di così in Swift 2 e nell'ultimo Xcode 7 (non è necessario specificare il tipo enum o .rawValue, i descrittori ecc ...)

Aggiornato per 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"

Un rapido esempio 3 e superiore se si utilizza Ints in 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

Per chiunque legga l'esempio nel capitolo "A Swift Tour" di "Il linguaggio di programmazione Swift" e cerchi un modo per semplificare il metodo simpleDescription (), facendo l'enum stesso in String facendo String(self)lo farà:

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

Dopo aver provato diversi modi, ho scoperto che se non si desidera utilizzare:

let audience = Audience.Public.toRaw()

Puoi ancora archiviarlo usando una struttura

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

quindi il tuo codice:

let audience = Audience.Public

funzionerà come previsto. Non è carino e ci sono alcuni aspetti negativi perché non si utilizza un "enum", non è possibile utilizzare il collegamento solo aggiungendo. Privato né funzionerà con i casi switch.

Esistono diversi modi per farlo. O potresti definire una funzione nell'enum che restituisce la stringa in base al valore del tipo enum:

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

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

Oppure puoi provare questo:

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

E per usarlo:

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

A partire da Swift 3.0 è possibile

var str = String(describing: Audience.friends)