Najlepsza praktyka wdrażania dostępnego inicjatora w języku Swift

Za pomocą poniższego kodu próbuję zdefiniować prostą klasę modelu i jej dostępny inicjalizator, który jako parametr przyjmuje słownik (json-). Inicjator powinien zwrócić, niljeśli nazwa użytkownika nie jest zdefiniowana w oryginalnym pliku json.

1. Dlaczego kod się nie kompiluje? Komunikat o błędzie mówi:

Wszystkie przechowywane właściwości wystąpienia klasy muszą zostać zainicjowane przed zwróceniem wartości nil z inicjatora.

To nie ma sensu. Dlaczego powinienem inicjalizować te właściwości, kiedy planuję powrót nil?

2. Czy moje podejście jest właściwe, czy też byłyby inne pomysły lub wspólne wzorce, aby osiągnąć mój cel?

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

Aktualizacja: z dziennika zmian Swift 2.2 (opublikowanego 21 marca 2016 r.):

Wyznaczone inicjatory klas zadeklarowane jako dostępne lub zgłaszające mogą teraz zwracać odpowiednio nil lub zgłaszać błąd, zanim obiekt zostanie w pełni zainicjowany.

Dla Swift 2.1 i starszych:

Zgodnie z dokumentacją Apple (i błędem kompilatora), klasa musi zainicjować wszystkie swoje przechowywane właściwości przed powrotem nilz dostępnego inicjatora:

Jednak w przypadku klas dostępny inicjator może wyzwolić błąd inicjalizacji tylko wtedy, gdy wszystkie przechowywane właściwości wprowadzone przez tę klasę zostały ustawione na wartość początkową i nastąpiło delegowanie inicjatora.

Uwaga: w rzeczywistości działa dobrze w przypadku struktur i wyliczeń, ale nie klas.

Sugerowanym sposobem obsługi przechowywanych właściwości, których nie można zainicjować przed niepowodzeniem inicjatora, jest zadeklarowanie ich jako niejawnie rozpakowanych opcji.

Przykład z dokumentów:

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

W powyższym przykładzie właściwość name klasy Product jest zdefiniowana jako posiadająca niejawnie rozpakowany opcjonalny typ ciągu (String!). Ponieważ jest to typ opcjonalny, oznacza to, że właściwość name ma domyślną wartość nil, zanim zostanie przypisana określona wartość podczas inicjalizacji. Ta domyślna wartość zero z kolei oznacza, że ​​wszystkie właściwości wprowadzone przez klasę Product mają prawidłową wartość początkową. W rezultacie dostępny inicjator dla produktu może wyzwolić błąd inicjalizacji na początku inicjatora, jeśli zostanie przekazany pusty ciąg, przed przypisaniem określonej wartości do właściwości name w inicjatorze.

W twoim przypadku, jednak po prostu definiując userNamejako String!nie naprawić błąd kompilacji, ponieważ wciąż trzeba się martwić o inicjowanie właściwości na swojej klasy bazowej NSObject. Na szczęście z userNamedefinicją a String!, możesz zadzwonić super.init()przed tobą, return nilco zainicjuje twoją NSObjectklasę bazową i naprawi błąd kompilacji.

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

To nie ma sensu. Dlaczego powinienem inicjalizować te właściwości, kiedy planuję zwrócić zero?

Według Chrisa Lattnera jest to błąd. Oto, co mówi:

Jest to ograniczenie implementacyjne w kompilatorze Swift 1.1, udokumentowane w informacjach o wydaniu. Kompilator obecnie nie jest w stanie zniszczyć częściowo zainicjowanych klas we wszystkich przypadkach, więc nie pozwala na utworzenie sytuacji, w której musiałby to zrobić. Uważamy, że jest to błąd, który należy naprawić w przyszłych wydaniach, a nie funkcja.

Źródło

EDYTOWAĆ:

Tak więc Swift jest teraz open source i zgodnie z tym dziennikiem zmian jest teraz naprawiony w migawkach swift 2.2

Wyznaczone inicjatory klas zadeklarowane jako dostępne lub zgłaszające mogą teraz zwracać odpowiednio nil lub zgłaszać błąd, zanim obiekt zostanie w pełni zainicjowany.

Akceptuję, że odpowiedź Mike'a S jest rekomendacją Apple, ale nie sądzę, że jest to najlepsza praktyka. Istotą silnego systemu typów jest przeniesienie błędów uruchomieniowych do czasu kompilacji. To „rozwiązanie” przeczy temu celowi. IMHO, lepiej byłoby przejść dalej i zainicjować nazwę użytkownika, ""a następnie sprawdzić ją po super.init (). Jeśli puste nazwy użytkowników są dozwolone, ustaw 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
        }
    }
}

Innym sposobem obejścia tego ograniczenia jest praca z funkcjami klas w celu wykonania inicjalizacji. Możesz nawet chcieć przenieść tę funkcję do rozszerzenia:

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

Używanie go stałoby się:

if let user = User.fromDictionary(someDict) {

     // Party hard
}

Chociaż Swift 2.2 został wydany i nie musisz już w pełni inicjalizować obiektu przed niepowodzeniem inicjalizatora, musisz wstrzymać swoje konie do czasu naprawienia https://bugs.swift.org/browse/SR-704 .

Dowiedziałem się, że można to zrobić w Swift 1.2

Jest kilka warunków:

• Wymagane właściwości powinny być zadeklarowane jako niejawnie rozpakowane opcje opcjonalne
• Przypisz wartość do wymaganych właściwości dokładnie raz. Ta wartość może wynosić zero.
• Następnie wywołaj super.init (), jeśli twoja klasa dziedziczy po innej klasie.
• Po przypisaniu wartości wszystkim wymaganym właściwościom sprawdź, czy ich wartość jest zgodna z oczekiwaniami. Jeśli nie, zwróć zero.

Przykład:

class ClassName: NSObject {

    let property: String!

    init?(propertyValue: String?) {

        self.property = propertyValue

        super.init()

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

Dostępny inicjator dla typu wartości (czyli struktury lub wyliczenia) może wyzwolić błąd inicjalizacji w dowolnym momencie w ramach jego implementacji inicjatora

Jednak w przypadku klas dostępny inicjator może wyzwolić błąd inicjalizacji tylko wtedy, gdy wszystkie przechowywane właściwości wprowadzone przez tę klasę zostały ustawione na wartość początkową i nastąpiło delegowanie inicjatora.

Fragment z: Apple Inc. „ Swift Programming Language. ”IBooks. https://itun.es/sg/jEUH0.l

Możesz skorzystać z wygody w inicjalizacji :

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