Swift: przekonwertować wartość wyliczenia na ciąg?

Biorąc pod uwagę następujące wyliczenie:

enum Audience {
    case Public
    case Friends
    case Private
}

Jak uzyskać ciąg znaków "Public"ze audiencestałej poniżej?

let audience = Audience.Public

Nie jestem pewien, w której wersji Swift ta funkcja została dodana, ale teraz ( Swift 2.1 ) potrzebujesz tylko tego kodu:

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

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

Gdy ciągi są używane dla surowych wartości, niejawną wartością dla każdego przypadku jest tekst jego nazwy .

[…]

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

W powyższym przykładzie CompassPoint.south ma niejawną wartość surową „południe” i tak dalej.

Dostęp do surowej wartości przypadku wyliczenia uzyskuje się z jego właściwością rawValue:

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

Źródło.

Idiomatyczny interfejs do „pobierania ciągu znaków” polega na użyciu CustomStringConvertible interfejsu i dostępie do metody descriptionpobierającej. Zdefiniuj enumjako:

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

W akcji:

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

Zaktualizowany : Dla Swift> = 2,0, otrzymuje PrintablesięCustomStringConvertible

Uwaga : użycie CustomStringConvertiblepozwala Foona przyjęcie innego surowego typu. Na przykład enum Foo : Int, CustomStringConvertible { ... }jest to możliwe. Ta wolność może być przydatna.

Na razie przedefiniuję wyliczenie jako:

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

abym mógł:

audience.toRaw() // "Public"

Ale czy ta nowa definicja wyliczenia nie jest zbędna? Czy mogę zachować początkową definicję wyliczenia i zrobić coś takiego:

audience.toString() // "Public"

W Swift 3 możesz tego użyć

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

od Swift, jak używać enum, aby uzyskać wartość ciągu

Lubię używać Printablez Raw Values.

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

    var description: String {
        return self.rawValue
    }
}

Wtedy możemy zrobić:

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

lub

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

Zaktualizowano w celu wydania Xcode 7 GM. Teraz działa tak, jak można by się spodziewać - dzięki 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!"

To nie może być prostsze niż to w Swift 2 i najnowszym Xcode 7 (nie ma potrzeby określania typu wyliczenia ani .rawValue, deskryptorów itp.)

Zaktualizowano dla Swift 3 i Xcode 8:

    enum Audience {
        case Public
        case Friends
        case Private
    }

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

Szybki przykład 3 i wyżej, jeśli używasz Ints w 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

Dla każdego, kto czyta przykład w rozdziale „Swift Tour” książki „Swift Programming Language” i szuka sposobu na uproszczenie metody simpleDescription (), wystarczy przekonwertowanie samego wyliczenia na String przez wykonanie String(self):

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

Po wypróbowaniu kilku różnych sposobów stwierdziłem, że jeśli nie chcesz używać:

let audience = Audience.Public.toRaw()

Nadal możesz zarchiwizować go za pomocą struktury

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

to twój kod:

let audience = Audience.Public

będzie działać zgodnie z oczekiwaniami. To nie jest ładne i ma pewne wady, ponieważ nie używasz "wyliczenia", nie możesz użyć skrótu tylko dodając .Private też nie będzie działać z przełącznikami.

Można to zrobić na wiele sposobów. Albo możesz zdefiniować funkcję w wyliczeniu, która zwraca ciąg na podstawie wartości typu wyliczenia:

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

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

Lub możesz spróbować tego:

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

I aby z niego skorzystać:

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

Począwszy od Swift 3.0 możesz

var str = String(describing: Audience.friends)