Primordial Enum init?(rawValue: String) pour ne pas être en option

Je veux avoir l'init de rawValue pour mon enum Swift pour retourner la valeur par défaut si rawValue init sera de retour nul.
Maintenant j'ai quelque chose comme ceci:

public init(fromRawValue: String){
        self = Language(rawValue: fromRawValue) ?? .English
}

Je n'aime pas cela, car il est complètement initializer.
J'ai essayé de faire quelque chose comme ceci:

public init(rawValue: String){
        self = Language(rawValue: fromRawValue) ?? .English
}

Mais j'ai eu runtime exception avec un mauvais accès. Je peux en quelque sorte le faire fonctionner ou j'ai juste à utiliser cette nouvelle et je ne peut pas remplacer celui d'origine pour ne pas être en option?

Je voudrais savoir si il possible de remplacer init d'origine de rawValue pas de solution complètement nouvelle qui est à l'aide de failable un.

InformationsquelleAutor Prettygeek | 2016-01-31
  1. 110

    L'initialisation par défaut est failable. Cela signifie que si le reçu paramètre ne correspond pas valide enum cas, il n'est de retour nil.

    Maintenant, vous voulez faire 2 choses incompatibles:

    1. Vous voulez redéfinir l'initialisation par défaut, il n'est pas failable. Enfait vous voulez, par défaut, une valeur d'enum créé lors de la réception de l'param n'est pas valide.
    2. À l'intérieur de votre redéfini initialiseur vous voulez appeler une failable initialiseur (qui n'existe plus) en utilisant le même nom de la nouvelle.

    Ce n'est pas possible, j'ai les 3 solutions possibles comme suit:

    1) la Création d'un autre init

    Vous définissez un nouveau pas failable initialisation avec une valeur par défaut, un autre nom du paramètre et à l'intérieur de ce que vous appelez la valeur par défaut failable initialiseur.

    enum Language: String {

    case english = "English", italian = "Italian", french = "French"

    init(fromRawValue: String){
        self = Language(rawValue: fromRawValue) ?? .english
    }
}

    2) Redéfinition de la valeur par défaut init

    Vous redéfinir l'initialisation par défaut, vous en faites pas failable et vous écrivez la logique à l'intérieur.

    enum Language: String {

    case english = "English", italian = "Italian", french = "French"

    init(rawValue: String) {
        switch rawValue {
        case "Italian": self = .italian
        case "French": self = .french
        default: self = .english
        }
    }
}

    3) la Création d'un func statiques

    enum Language: String {

    case english = "English", italian = "Italian", french = "French"

    static func build(rawValue: String) -> Language {
        return Language(rawValue: rawValue) ?? .english
    }
}

    Vous pouvez maintenant construire un Language valeur de l'écriture:

    let italian = Language.build(rawValue: "Italian") //Italian
let defaultValue = Language.build(rawValue: "Wrong input") // English
    • Fantastique réponse. Le "self = ..." a été inestimable. Toutes sortes de caché Swift pépites dans ce lang 🙂
    • Vous pouvez remplacer Language en approche #1 's de l'initialiseur de type(of: self).init pour une approche plus générique.
    InformationsquelleAutor Luca Angeletti
  2. 5

    L'ajout de Luca la solution pour la redéfinition de l'init par défaut, il est possible de faire de la rawValue type de paramètre facultatif, ce qui réduit le code sur le site d'appel lorsque la source de données n'est pas fiable.

    enum PrecipitationType: String {
    case rain, snow, sleet, none

    typealias RawValue = String

    init(rawValue: String?) {
        guard let rawValue = rawValue else { self = .none; return }

        switch rawValue {
            case PrecipitationType.rain.rawValue: self = .rain
            case PrecipitationType.snow.rawValue: self = .snow
            case PrecipitationType.sleet.rawValue: self = .sleet
            default: self = .none
        }
    }
}

    Quand j'ai d'abord essayé ce qu'elle a généré de multiples erreurs. La clé a été de redéfinir le RawValue typealias de maintenir la conformité aux RawRepresentable.

    InformationsquelleAutor Nathan Hosselton