Swift: convertir la valeur d'énumération en chaîne?

Compte tenu de l'énumération suivante:

enum Audience {
    case Public
    case Friends
    case Private
}

Comment obtenir la chaîne "Public"de la audienceconstante ci-dessous?

let audience = Audience.Public

Vous ne savez pas dans quelle version Swift cette fonctionnalité a été ajoutée, mais pour le moment ( Swift 2.1 ), vous n'avez besoin que de ce code:

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

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

Lorsque des chaînes sont utilisées pour des valeurs brutes, la valeur implicite de chaque observation est le texte du nom de cette observation .

[...]

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

Dans l'exemple ci-dessus, CompassPoint.south a une valeur brute implicite de «sud», et ainsi de suite.

Vous accédez à la valeur brute d'un cas d'énumération avec sa propriété rawValue:

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

La source.

L'interface idiomatique pour «obtenir une chaîne» consiste à utiliser l' CustomStringConvertible interface et à accéder au descriptiongetter. Définissez votre enumcomme:

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 action:

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

Mise à jour : pour Swift> = 2.0, remplacé PrintableparCustomStringConvertible

Remarque : l'utilisation CustomStringConvertiblepermet Food'adopter un type brut différent. Par exemple, enum Foo : Int, CustomStringConvertible { ... }c'est possible. Cette liberté peut être utile.

Pour l'instant, je redéfinirai l'énumération comme suit:

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

pour que je puisse faire:

audience.toRaw() // "Public"

Mais cette nouvelle définition d'énumération n'est-elle pas redondante? Puis-je conserver la définition initiale de l'énumération et faire quelque chose comme:

audience.toString() // "Public"

Dans Swift 3, vous pouvez utiliser ceci

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

de Swift comment utiliser enum pour obtenir une valeur de chaîne

J'aime utiliser Printableavec Raw Values.

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

    var description: String {
        return self.rawValue
    }
}

Ensuite, nous pouvons faire:

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

ou

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

Mis à jour pour la sortie de Xcode 7 GM. Cela fonctionne comme on l'espère maintenant - merci 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!"

Cela ne pourrait pas être plus simple que cela dans Swift 2 et le dernier Xcode 7 (pas besoin de spécifier le type enum, ou .rawValue, les descripteurs, etc.)

Mis à jour pour Swift 3 et Xcode 8:

    enum Audience {
        case Public
        case Friends
        case Private
    }

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

Un exemple Swift 3 et supérieur si vous utilisez Ints dans 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

Pour toute personne lisant l'exemple du chapitre "A Swift Tour" de "The Swift Programming Language" et cherchant un moyen de simplifier la méthode simpleDescription (), convertir l'énumération elle-même en String en faisant le String(self)fera:

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

Après avoir essayé plusieurs façons différentes, j'ai trouvé que si vous ne voulez pas utiliser:

let audience = Audience.Public.toRaw()

Vous pouvez toujours l'archiver en utilisant une structure

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

puis votre code:

let audience = Audience.Public

fonctionnera comme prévu. Ce n'est pas joli et il y a quelques inconvénients parce que vous n'utilisez pas de "enum", vous ne pouvez pas utiliser le raccourci uniquement en ajoutant .Private ne fonctionnera pas non plus avec les cas de commutation.

Il existe plusieurs façons de procéder. Soit vous pouvez définir une fonction dans l'énumération qui renvoie la chaîne en fonction de la valeur du type enum:

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

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

Ou vous pouvez essayer ceci:

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

Et pour l'utiliser:

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

À partir de Swift 3.0, vous pouvez

var str = String(describing: Audience.friends)