Meilleures pratiques pour implémenter un initialiseur disponible dans Swift

Avec le code suivant, j'essaye de définir une classe de modèle simple et c'est un initialiseur disponible, qui prend un dictionnaire (json-) comme paramètre. L'initialiseur doit retourner nilsi le nom d'utilisateur n'est pas défini dans le json d'origine.

1. Pourquoi le code ne se compile-t-il pas? Le message d'erreur dit:

Toutes les propriétés stockées d'une instance de classe doivent être initialisées avant de renvoyer nil à partir d'un initialiseur.

Cela n'a pas de sens. Pourquoi devrais-je initialiser ces propriétés lorsque je prévois de revenir nil?

2. Mon approche est-elle la bonne ou y aurait-il d'autres idées ou modèles communs pour atteindre mon objectif?

class User: NSObject {

    let userName: String
    let isSuperUser: Bool = false
    let someDetails: [String]?

    init?(dictionary: NSDictionary) {
        if let value: String = dictionary["user_name"] as? String {
            userName = value
        }
        else {
           return nil
        }

        if let value: Bool = dictionary["super_user"] as? Bool {
            isSuperUser = value
        }

        someDetails = dictionary["some_details"] as? Array

        super.init()
    }
}

Mise à jour: à partir du journal des modifications de Swift 2.2 (publié le 21 mars 2016):

Les initialiseurs de classe désignés déclarés comme disponibles ou lancés peuvent désormais renvoyer nil ou générer une erreur, respectivement, avant que l'objet n'ait été complètement initialisé.

Pour Swift 2.1 et versions antérieures:

Selon la documentation d'Apple (et l'erreur de votre compilateur), une classe doit initialiser toutes ses propriétés stockées avant de revenir nildepuis un initialiseur disponible:

Pour les classes, cependant, un initialiseur disponible peut déclencher un échec d'initialisation uniquement après que toutes les propriétés stockées introduites par cette classe ont été définies sur une valeur initiale et que toute délégation d'initialisation a eu lieu.

Remarque: cela fonctionne bien pour les structures et les énumérations, mais pas pour les classes.

La méthode suggérée pour gérer les propriétés stockées qui ne peuvent pas être initialisées avant l'échec de l'initialiseur est de les déclarer comme des options implicitement déballées.

Exemple tiré de la documentation:

class Product {
    let name: String!
    init?(name: String) {
        if name.isEmpty { return nil }
        self.name = name
    }
}

Dans l'exemple ci-dessus, la propriété name de la classe Product est définie comme ayant un type de chaîne facultatif implicitement déroulé (String!). Etant donné qu'elle est de type facultatif, cela signifie que la propriété name a une valeur par défaut de nil avant de recevoir une valeur spécifique lors de l'initialisation. Cette valeur par défaut de nil signifie à son tour que toutes les propriétés introduites par la classe Product ont une valeur initiale valide. Par conséquent, l'initialiseur disponible pour Product peut déclencher un échec d'initialisation au début de l'initialiseur s'il reçoit une chaîne vide, avant d'affecter une valeur spécifique à la propriété name dans l'initialiseur.

Dans votre cas, cependant, définir simplement userNamecomme String!ne résout pas l'erreur de compilation parce que vous avez encore à vous soucier de l' initialisation des propriétés de votre classe de base, NSObject. Heureusement, avec userNamedéfini comme a String!, vous pouvez réellement appeler super.init()avant vous, return nilce qui initiera votre NSObjectclasse de base et corrigera l'erreur de compilation.

class User: NSObject {

    let userName: String!
    let isSuperUser: Bool = false
    let someDetails: [String]?

    init?(dictionary: NSDictionary) {
        super.init()

        if let value = dictionary["user_name"] as? String {
            self.userName = value
        }
        else {
            return nil
        }

        if let value: Bool = dictionary["super_user"] as? Bool {
            self.isSuperUser = value
        }

        self.someDetails = dictionary["some_details"] as? Array
    }
}

Cela n'a pas de sens. Pourquoi devrais-je initialiser ces propriétés alors que je prévois de renvoyer nil?

Selon Chris Lattner, c'est un bug. Voici ce qu'il dit:

Il s'agit d'une limitation d'implémentation dans le compilateur swift 1.1, documentée dans les notes de publication. Le compilateur est actuellement incapable de détruire les classes partiellement initialisées dans tous les cas, donc il interdit la formation d'une situation où il devrait le faire. Nous considérons cela comme un bogue à corriger dans les prochaines versions, pas comme une fonctionnalité.

La source

ÉDITER:

Donc, swift est maintenant open source et selon ce journal des modifications, il est maintenant corrigé dans les instantanés de swift 2.2

Les initialiseurs de classe désignés déclarés comme disponibles ou lancés peuvent désormais renvoyer nil ou générer une erreur, respectivement, avant que l'objet n'ait été complètement initialisé.

J'accepte que la réponse de Mike S soit la recommandation d'Apple, mais je ne pense pas que ce soit la meilleure pratique. L'intérêt d'un système de type fort est de déplacer les erreurs d'exécution vers la compilation. Cette «solution» va à l'encontre de cet objectif. IMHO, mieux serait d'aller de l'avant et d'initialiser le nom d'utilisateur "", puis de le vérifier après le super.init (). Si des noms d'utilisateur vides sont autorisés, définissez un indicateur.

class User: NSObject {
    let userName: String = ""
    let isSuperUser: Bool = false
    let someDetails: [String]?

    init?(dictionary: [String: AnyObject]) {
        if let user_name = dictionary["user_name"] as? String {
            userName = user_name
        }

        if let value: Bool = dictionary["super_user"] as? Bool {
            isSuperUser = value
        }

        someDetails = dictionary["some_details"] as? Array

        super.init()

        if userName.isEmpty {
            return nil
        }
    }
}

Une autre façon de contourner la limitation est de travailler avec une classe-fonctions pour faire l'initialisation. Vous pourriez même vouloir déplacer cette fonction vers une extension:

class User: NSObject {

    let username: String
    let isSuperUser: Bool
    let someDetails: [String]?

    init(userName: String, isSuperUser: Bool, someDetails: [String]?) {

         self.userName = userName
         self.isSuperUser = isSuperUser
         self.someDetails = someDetails

         super.init()
    }
}

extension User {

    class func fromDictionary(dictionary: NSDictionary) -> User? {

        if let username: String = dictionary["user_name"] as? String {

            let isSuperUser = (dictionary["super_user"] as? Bool) ?? false
            let someDetails = dictionary["some_details"] as? [String]

            return User(username: username, isSuperUser: isSuperUser, someDetails: someDetails)
        }

        return nil
    }
}

L'utiliser deviendrait:

if let user = User.fromDictionary(someDict) {

     // Party hard
}

Bien que Swift 2.2 ait été publié et que vous n'ayez plus à initialiser complètement l'objet avant d'échouer l'initialiseur, vous devez tenir vos chevaux jusqu'à ce que https://bugs.swift.org/browse/SR-704 soit corrigé.

J'ai découvert que cela pouvait être fait dans Swift 1.2

Il y a quelques conditions:

• Les propriétés requises doivent être déclarées comme des options implicitement déroulées
• Attribuez une valeur à vos propriétés requises une seule fois. Cette valeur peut être nulle.
• Appelez ensuite super.init () si votre classe hérite d'une autre classe.
• Une fois que toutes vos propriétés requises ont reçu une valeur, vérifiez si leur valeur est celle attendue. Sinon, renvoyez nul.

Exemple:

class ClassName: NSObject {

    let property: String!

    init?(propertyValue: String?) {

        self.property = propertyValue

        super.init()

        if self.property == nil {
            return nil
        }
    }
}

Un initialiseur disponible pour un type valeur (c'est-à-dire une structure ou une énumération) peut déclencher un échec d'initialisation à tout moment dans son implémentation d'initialisation

Pour les classes, cependant, un initialiseur disponible peut déclencher un échec d'initialisation uniquement après que toutes les propriétés stockées introduites par cette classe ont été définies sur une valeur initiale et que toute délégation d'initialisation a eu lieu.

Extrait de: Apple Inc. « Le langage de programmation Swift. «IBooks. https://itun.es/sg/jEUH0.l

Vous pouvez utiliser l' init de commodité :

class User: NSObject {
    let userName: String
    let isSuperUser: Bool = false
    let someDetails: [String]?

    init(userName: String, isSuperUser: Bool, someDetails: [String]?) {
        self.userName = userName
        self.isSuperUser = isSuperUser
        self.someDetails = someDetails
    }     

    convenience init? (dict: NSDictionary) {            
       guard let userName = dictionary["user_name"] as? String else { return nil }
       guard let isSuperUser = dictionary["super_user"] as? Bool else { return nil }
       guard let someDetails = dictionary["some_details"] as? [String] else { return nil }

       self.init(userName: userName, isSuperUser: isSuperUser, someDetails: someDetails)
    } 
}