Best practice per implementare un inizializzatore non riuscito in Swift

Con il codice seguente cerco di definire una semplice classe del modello ed è un inizializzatore failable, che accetta un dizionario (json-) come parametro. L'inizializzatore dovrebbe restituire nilse il nome utente non è definito nel json originale.

1. Perché il codice non viene compilato? Il messaggio di errore dice:

Tutte le proprietà memorizzate di un'istanza di classe devono essere inizializzate prima di restituire nil da un inizializzatore.

Non ha senso. Perché dovrei inizializzare queste proprietà quando prevedo di tornare nil?

2. Il mio approccio è quello giusto o ci sarebbero altre idee o schemi comuni per raggiungere il mio obiettivo?

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

Aggiornamento: dal registro modifiche di Swift 2.2 (rilasciato il 21 marzo 2016):

Gli inizializzatori di classe designati dichiarati come failable o throwing possono ora restituire zero o generare un errore, rispettivamente, prima che l'oggetto sia stato completamente inizializzato.

Per Swift 2.1 e versioni precedenti:

Secondo la documentazione di Apple (e l'errore del compilatore), una classe deve inizializzare tutte le sue proprietà memorizzate prima di tornare nilda un inizializzatore non riuscito:

Per le classi, tuttavia, un inizializzatore non riuscito può attivare un errore di inizializzazione solo dopo che tutte le proprietà memorizzate introdotte da quella classe sono state impostate su un valore iniziale e qualsiasi delega dell'inizializzatore ha avuto luogo.

Nota: in realtà funziona bene per strutture ed enumerazioni, ma non per le classi.

Il modo suggerito per gestire le proprietà archiviate che non possono essere inizializzate prima che l'inizializzatore fallisca è dichiararle come optionals implicitamente scartate.

Esempio dai documenti:

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

Nell'esempio precedente, la proprietà name della classe Product è definita come avente un tipo di stringa facoltativo non incluso nel wrapping (String!). Poiché è di un tipo facoltativo, ciò significa che la proprietà name ha un valore predefinito nil prima che le venga assegnato un valore specifico durante l'inizializzazione. Questo valore predefinito di nil a sua volta significa che tutte le proprietà introdotte dalla classe Product hanno un valore iniziale valido. Di conseguenza, l'inizializzatore non riuscito per Product può attivare un errore di inizializzazione all'inizio dell'inizializzatore se viene passata una stringa vuota, prima di assegnare un valore specifico alla proprietà name all'interno dell'inizializzatore.

Nel tuo caso, però, semplicemente definendo userNamecome String!non si risolve l'errore di compilazione perché hai ancora bisogno di preoccuparsi per inizializzare le proprietà sulla vostra classe di base, NSObject. Fortunatamente, con userNamedefinito come a String!, puoi effettivamente chiamare super.init()prima di te return nilche avvierà la tua NSObjectclasse base e correggerà l'errore di compilazione.

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

Non ha senso. Perché dovrei inizializzare quelle proprietà quando prevedo di restituire zero?

Secondo Chris Lattner questo è un bug. Ecco cosa dice:

Questa è una limitazione dell'implementazione nel compilatore swift 1.1, documentata nelle note di rilascio. Il compilatore non è attualmente in grado di distruggere le classi parzialmente inizializzate in tutti i casi, quindi non consente la formazione di una situazione in cui dovrebbe farlo. Consideriamo questo un bug da correggere nelle versioni future, non una funzionalità.

fonte

MODIFICARE:

Così swift è ora open source e secondo questo log delle modifiche ora è stato risolto in istantanee di swift 2.2

Gli inizializzatori di classe designati dichiarati come failable o throwing possono ora restituire zero o generare un errore, rispettivamente, prima che l'oggetto sia stato completamente inizializzato.

Accetto che la risposta di Mike S sia la raccomandazione di Apple, ma non credo che sia la migliore pratica. Il punto centrale di un sistema di tipi forte è spostare gli errori di runtime in tempo di compilazione. Questa "soluzione" sconfigge tale scopo. IMHO, meglio sarebbe andare avanti e inizializzare il nome utente su ""e poi controllarlo dopo super.init (). Se sono consentiti userNames vuoti, impostare un flag.

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

Un altro modo per aggirare la limitazione è lavorare con funzioni di classe per eseguire l'inizializzazione. Potresti anche voler spostare quella funzione in un'estensione:

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

Usarlo diventerebbe:

if let user = User.fromDictionary(someDict) {

     // Party hard
}

Sebbene Swift 2.2 sia stato rilasciato e non sia più necessario inizializzare completamente l'oggetto prima di fallire l'inizializzazione, è necessario trattenere i cavalli finché https://bugs.swift.org/browse/SR-704 non viene risolto.

Ho scoperto che questo può essere fatto in Swift 1.2

Ci sono alcune condizioni:

• Le proprietà richieste dovrebbero essere dichiarate come optionals implicitamente scartate
• Assegna un valore alle proprietà richieste esattamente una volta. Questo valore può essere nullo.
• Quindi chiama super.init () se la tua classe eredita da un'altra classe.
• Dopo che a tutte le proprietà richieste è stato assegnato un valore, controlla se il loro valore è quello previsto. In caso contrario, restituisci zero.

Esempio:

class ClassName: NSObject {

    let property: String!

    init?(propertyValue: String?) {

        self.property = propertyValue

        super.init()

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

Un inizializzatore non riuscito per un tipo di valore (ovvero una struttura o enumerazione) può attivare un errore di inizializzazione in qualsiasi punto all'interno della sua implementazione dell'inizializzatore

Per le classi, tuttavia, un inizializzatore non riuscito può attivare un errore di inizializzazione solo dopo che tutte le proprietà memorizzate introdotte da quella classe sono state impostate su un valore iniziale e qualsiasi delega dell'inizializzatore ha avuto luogo.

Estratto da: Apple Inc. “ The Swift Programming Language. "IBooks. https://itun.es/sg/jEUH0.l

Puoi usare convenienza init :

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