Come ottenere il nome del valore di enumerazione in Swift?

Se ho un'enumerazione con Integervalori non elaborati :

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

let city = City.Melbourne

Come posso convertire un cityvalore in una stringa Melbourne? Questo tipo di introspezione di un nome tipo è disponibile nella lingua?

Qualcosa di simile (questo codice non funzionerà):

println("Your city is \(city.magicFunction)")
> Your city is Melbourne

A partire da Xcode 7 beta 5 (Swift versione 2) è ora possibile stampare nomi di tipi ed enum case per impostazione predefinita utilizzando print(_:)o convertire Stringutilizzando Stringl' init(_:)inizializzatore o la sintassi di interpolazione delle stringhe. Quindi, per il tuo esempio:

enum City: Int {
    case Melbourne = 1, Chelyabinsk, Bursa
}
let city = City.Melbourne

print(city)
// prints "Melbourne"

let cityName = "\(city)"   // or `let cityName = String(city)`
// cityName contains "Melbourne"

Quindi non è più necessario definire e mantenere una funzione di convenienza che attiva ciascun caso per restituire una stringa letterale. Inoltre, questo funziona automaticamente per qualsiasi enum, anche se non viene specificato alcun tipo di valore non elaborato.

debugPrint(_:)e String(reflecting:)può essere utilizzato per un nome completo:

debugPrint(city)
// prints "App.City.Melbourne" (or similar, depending on the full scope)

let cityDebugName = String(reflecting: city)
// cityDebugName contains "App.City.Melbourne"

Si noti che è possibile personalizzare ciò che viene stampato in ciascuno di questi scenari:

extension City: CustomStringConvertible {
    var description: String {
        return "City \(rawValue)"
    }
}

print(city)
// prints "City 1"

extension City: CustomDebugStringConvertible {
    var debugDescription: String {
        return "City (rawValue: \(rawValue))"
    }
}

debugPrint(city)
// prints "City (rawValue: 1)"

(Non ho trovato il modo di chiamare questo valore "predefinito", ad esempio, per stampare "La città è Melbourne" senza ricorrere a un'istruzione switch. L'uso \(self)nell'implementazione di description/ debugDescriptionprovoca una ricorsione infinita.)

Le osservazioni di cui sopra String's init(_:)& init(reflecting:)initializers descrivono esattamente ciò che viene stampato, a seconda di ciò che il tipo soddisfa riflesse a:

extension String {
    /// Initialize `self` with the textual representation of `instance`.
    ///
    /// * If `T` conforms to `Streamable`, the result is obtained by
    ///   calling `instance.writeTo(s)` on an empty string s.
    /// * Otherwise, if `T` conforms to `CustomStringConvertible`, the
    ///   result is `instance`'s `description`
    /// * Otherwise, if `T` conforms to `CustomDebugStringConvertible`,
    ///   the result is `instance`'s `debugDescription`
    /// * Otherwise, an unspecified result is supplied automatically by
    ///   the Swift standard library.
    ///
    /// - SeeAlso: `String.init<T>(reflecting: T)`
    public init<T>(_ instance: T)

    /// Initialize `self` with a detailed textual representation of
    /// `subject`, suitable for debugging.
    ///
    /// * If `T` conforms to `CustomDebugStringConvertible`, the result
    ///   is `subject`'s `debugDescription`.
    ///
    /// * Otherwise, if `T` conforms to `CustomStringConvertible`, the result
    ///   is `subject`'s `description`.
    ///
    /// * Otherwise, if `T` conforms to `Streamable`, the result is
    ///   obtained by calling `subject.writeTo(s)` on an empty string s.
    ///
    /// * Otherwise, an unspecified result is supplied automatically by
    ///   the Swift standard library.
    ///
    /// - SeeAlso: `String.init<T>(T)`
    public init<T>(reflecting subject: T)
}

Vedi le note di rilascio per informazioni su questa modifica.

Al momento non ci sono introspezioni sui casi di enum. Dovrai dichiararli ciascuno manualmente:

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

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

Se hai bisogno che il tipo raw sia un Int, dovrai fare un cambio da solo:

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

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

In Swift-3 (testato con Xcode 8.1) puoi aggiungere i seguenti metodi nel tuo 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) }
}

Puoi quindi usarlo come una normale chiamata di metodo sulla tua istanza enum. Potrebbe funzionare anche nelle precedenti versioni di Swift, ma non l'ho provato.

Nel tuo esempio:

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"

Se vuoi fornire questa funzionalità a tutti i tuoi enum, puoi renderlo un'estensione:

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

Questo funziona solo per enumerazioni Swift.

Per Objective-C enums l'unico modo attualmente sembra essere, ad esempio, di estendere l'enum CustomStringConvertiblefinendo con qualcosa del tipo:

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

E poi lanciare il enumas String:

String(UIDevice.currentDevice().batteryState)

L' String(describing:)inizializzatore può essere utilizzato per restituire il nome dell'etichetta del caso anche per gli enum con valori Raw non String:

enum Numbers: Int {
    case one = 1
    case two = 2
}

let one = String(describing: Numbers.one) // "one"
let two = String(describing: Numbers.two) // "two"

Nota che questo non funziona se l'enum usa il @objcmodificatore:

https://forums.swift.org/t/why-is-an-enum-returning-enumname-rather-than-caselabel-for-string-describing/27327

Le interfacce Swift generate per i tipi Objective-C a volte non includono il @objcmodificatore. Tali Enum sono tuttavia definiti in Objective-C, e quindi non funzionano come sopra.

Oltre al supporto String (...) (CustomStringConvertible) per gli enum in Swift 2.2, c'è anche un supporto di riflessione in qualche modo rotto per loro. Per i casi enum con valori associati è possibile ottenere l'etichetta del caso enum usando reflection:

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"

Per essere rotto, intendevo tuttavia che per gli enum "semplici", la labelproprietà calcolata sopra basata sulla riflessione ritorna nil(boo-hoo).

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

A quanto pare, la situazione con la riflessione dovrebbe migliorare dopo Swift 3. La soluzione per ora è String(…), come suggerito in una delle altre risposte:

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

Questo è così deludente.

Nel caso in cui tu abbia bisogno di quei nomi (di cui il compilatore conosce perfettamente l'ortografia esatta, ma rifiuta di consentire l'accesso - grazie a Swift team !! -) ma non vuoi o non puoi rendere String la base del tuo enum, un L'alternativa dettagliata e ingombrante è la seguente:

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

È possibile utilizzare quanto sopra come segue:

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

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

E otterrai il risultato atteso (codice per la colonna simile, ma non mostrato)

fetching element Title, column: Collections, row: 0

In quanto sopra, ho fatto in modo che la descriptionproprietà rimandasse al stringmetodo, ma è una questione di gusti. Si noti inoltre che le cosiddette staticvariabili devono essere qualificate nell'ambito dal nome del loro tipo che lo racchiude, poiché il compilatore è troppo amnesico e non è in grado di richiamare il contesto da solo ...

Il team Swift deve essere veramente comandato. Hanno creato un enum che non puoi enumeratee su cui puoi usare enumeratesono "Sequenze" ma non enum!

Mi sono imbattuto in questa domanda e volevo condividere un modo semplice per creare la funzione magica menzionata

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

    func magicFunction() -> String {
        return "\(self)"
    }
}

let city = City.Melbourne
city.magicFunction() //prints Melbourne

Swift ora ha ciò che è noto come valore grezzo assegnato in modo implicito . Fondamentalmente se non si danno valori grezzi a ciascun caso e l'enum è di tipo String, si deduce che il valore grezzo del caso sia esso stesso in formato stringa. Su, provaci.

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

let city = City.Melbourne.rawValue

// city is "Melbourne"

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

}

se la tua variabile "batteryState" chiama:

self.batteryState.description

Semplice ma funziona ...

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