web-dev-qa-db-fra.com

Swift: Convertir la valeur enum en String?

Étant donné l'énumération suivante:

enum Audience {
    case Public
    case Friends
    case Private
}

Comment obtenir la chaîne "Public" à partir de la constante audience ci-dessous?

let audience = Audience.Public
stringenumsswift
110
ma11hew28

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 pour chaque cas est le texte du nom de ce cas .

[...]

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

Dans l'exemple ci-dessus, CompassPoint.south a une valeur implicite brute de "sud", etc.

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"

Source.

114
DevAndArtist

L’interface idiomatique pour "obtenir une chaîne" consiste à utiliser l’interface CustomStringConvertible et à accéder à l’objet description. Définissez votre enum comme:

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, a remplacé Printable par CustomStringConvertible

Remarque : L'utilisation de CutomStringConvertible permet à Foo d'adopter un type brut différent. Par exemple, enum Foo : Int, CustomStringConvertible { ... } est possible. Cette liberté peut être utile.

179
GoZoner

Pour l'instant, je vais redéfinir 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 n'est-elle pas redondante? Puis-je conserver la définition de l'énumération initiale et faire quelque chose comme:

audience.toString() // "Public"
31
ma11hew28

Dans Swift 3, vous pouvez utiliser cette

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

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

23
Danil Shaykhutdinov

J'aime utiliser Printable avec 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"
22
Simple99

Mise à jour pour la publication 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!"
12
par

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

Mise à 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"
10
gbdavid

Pour tous ceux qui lisent l’exemple du chapitre "A Swift Tour" du chapitre "Langage de programmation Swift _" et qui cherchent un moyen de simplifier la méthode simpleDescription (), en convertissant l’énumère lui-même en String en faisant String(self) le 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)
        }
     }
   }
5
Vivek Gani

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
4
tsukimi

Après avoir essayé plusieurs façons, 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"
}

alors votre code:

let audience = Audience.Public

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

3
Adriano Spadoni

Il y a plusieurs façons de le faire. Vous pouvez également définir une fonction dans l'énum 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())
3
Dhruv Ramani