Jak uzyskać nazwę wartości wyliczenia w języku Swift?

W tej chwili nie ma introspekcji na temat przypadków enum. Będziesz musiał zadeklarować każdy z nich ręcznie:

enum City : String, Printable {
  case Melbourne = "Melbourne"
  case Chelyabinsk = "Chelyabinsk"
  case Bursa = "Bursa"

  var description : String {
    get {
        return self.rawValue
    }
  }
}

Uwaga : protokół Printable nie działa obecnie na placach zabaw. Jeśli chcesz zobaczyć ciąg znaków na placu zabaw, musisz ręcznie wywołać toRaw ()

Jeśli chcesz, aby surowy typ był Int, musisz zrobić przełącznik samodzielnie:

enum City : Int, Printable {
  case Melbourne = 1, Chelyabinsk, Bursa

  var description : String {
    get {
      switch(self) {
        case Melbourne:
          return "Melbourne"
        case Chelyabinsk:
          return "Chelyabinsk"
        case Bursa:
          return "Bursa"
      }
    }
  }
}

W Swift - 3 (testowanym z XCode 8.1) możesz dodać następujące metody w swoim enum:

/**
 * The name of the enumeration (as written in case).
 */
var name: String {
    get { return String(describing: self) }
}

/**
 * The full name of the enumeration
 * (the name of the enum plus dot plus the name as written in case).
 */
var description: String {
    get { return String(reflecting: self) }
}

Możesz użyć go jako normalnego wywołania metody na Twojej instancji enum. Może to również działać w poprzednich wersjach Swift, ale nie testowałem go.

W twoim przykładzie:

enum City: Int {
    case Melbourne = 1, Chelyabinsk, Bursa
    var name: String {
        get { return String(describing: self) }
    }
    var description: String {
        get { return String(reflecting: self) }
    }
}
let city = City.Melbourne

print(city.name)
// prints "Melbourne"

print(city.description)
// prints "City.Melbourne"

Jeśli chcesz udostępnić tę funkcjonalność wszystkim swoim enumom, możesz zrobić z niej rozszerzenie:

/**
 * Extend all enums with a simple method to derive their names.
 */
extension RawRepresentable where RawValue: Any {
  /**
   * The name of the enumeration (as written in case).
   */
  var name: String {
    get { return String(describing: self) }
  }

  /**
   * The full name of the enumeration
   * (the name of the enum plus dot plus the name as written in case).
   */
  var description: String {
    get { return String(reflecting: self) }
  }
}

To działa tylko dla Swift enums.

Dla Objective-C enumS jedynym sposobem obecnie wydaje się na przykład rozszerzenie enum oCustomStringConvertible zakończone czymś w rodzaju:

extension UIDeviceBatteryState: CustomStringConvertible {
    public var description: String {
        switch self {
        case Unknown:
            return "Unknown"
        case Unplugged:
            return "Unplugged"
        case Charging:
            return "Charging"
        case Full:
            return "Full"
        }
    }
}

A następnie rzuca enum jako String:

String(UIDevice.currentDevice().batteryState)

To takie rozczarowujące.

W Przypadku, Gdy potrzebujesz tych nazw (które kompilator doskonale zna dokładną pisownię, ale odmawia dostępu -- dziękuję Swift team!! -jeśli nie chcesz lub nie możesz uczynić String bazą twojego enum, czasochłonna alternatywa jest następująca:

enum ViewType : Int, Printable {

    case    Title
    case    Buttons
    case    View

    static let all = [Title, Buttons, View]
    static let strings = ["Title", "Buttons", "View"]

    func string() -> String {
        return ViewType.strings[self.rawValue]
    }

    var description:String {
        get {
            return string()
        }
    }
}

Możesz użyć powyższego w następujący sposób:

let elementType = ViewType.Title
let column = Column.Collections
let row = 0

println("fetching element \(elementType), column: \(column.string()), row: \(row)")

I otrzymasz oczekiwany wynik (kod dla kolumny podobny, ale nie pokazany)

fetching element Title, column: Collections, row: 0

W powyższym, I sprawiły, że właściwość description odnosi się z powrotem do metody string, ale jest to kwestia gustu. Zauważ również, że tak zwane zmienne static muszą być kwalifikowane przez nazwę ich typu, ponieważ kompilator jest zbyt amnezyjny i nie może sam przywołać kontekstu...

Drużyna Swift musi być naprawdę dowodzona. Stworzyli enum, którego nie można enumerate i na którym można użyć enumerate są "sekwencjami", ale nie enum!

Poza obsługą String (...) (CustomStringConvertible) dla enums w Swift 2.2, jest też nieco zepsuta obsługa odbicia dla nich. Dla przypadków enum z powiązanymi wartościami można uzyskać etykietę przypadku enum za pomocą odbicia:

enum City {
    case Melbourne(String)
    case Chelyabinsk
    case Bursa

    var label:String? {
        let mirror = Mirror(reflecting: self)
        return mirror.children.first?.label
    }
}

print(City.Melbourne("Foobar").label) // prints out "Melbourne"

Mówiąc o złamaniu, miałem jednak na myśli, że dla" prostych " enum, powyższa właściwość obliczeniowa oparta na odbiciu label zwraca po prostu nil (boo-hoo).

print(City.Chelyabinsk.label) // prints out nil

Sytuacja z odbiciem powinna być coraz lepsza po Swift 3, najwyraźniej. Na razie jednak rozwiązaniem jest String(…), jak sugerowano w jednej z innych odpowiedzi:

print(String(City.Chelyabinsk)) // prints out Cheylabinsk

Proste, ale działa...

enum ViewType : Int {
    case    Title
    case    Buttons
    case    View
}

func printEnumValue(enum: ViewType) {

    switch enum {
    case .Title: println("ViewType.Title")
    case .Buttons: println("ViewType.Buttons")
    case .View: println("ViewType.View")
    }
}

Swift ma teraz coś, co jest znane jako domyślnie przypisana wartość raw . Zasadniczo, jeśli nie podasz wartości nieprzetworzonych dla każdego przypadku, a enum jest typu String, wywnioskujesz, że nieprzetworzona wartość sprawy jest sama w formacie string. Spróbuj.

enum City: String {
  case Melbourne, Chelyabinsk, Bursa
}

let city = City.Melbourne.rawValue

// city is "Melbourne"

Dla swift:

extension UIDeviceBatteryState: CustomStringConvertible {
    public var description: String {
        switch self {
        case .unknown:
            return "unknown"
        case .unplugged:
            return "unplugged"
        case .charging:
            return "charging"
        case .full:
            return "full"
        }
    }
}

Jeśli twoja zmienna "batteryState" to wywołaj:

Self.batteryState.Opis