Erreur dans la classe Swift: propriété non initialisée lors de l'appel super.init

J'ai deux classes, ShapeetSquare

class Shape {
    var numberOfSides = 0
    var name: String
    init(name:String) {
        self.name = name
    }
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}

class Square: Shape {
    var sideLength: Double

    init(sideLength:Double, name:String) {
        super.init(name:name) // Error here
        self.sideLength = sideLength
        numberOfSides = 4
    }
    func area () -> Double {
        return sideLength * sideLength
    }
}

Avec l'implémentation ci-dessus, j'obtiens l'erreur:

property 'self.sideLength' not initialized at super.init call
    super.init(name:name)

Pourquoi dois-je régler self.sideLengthavant d'appeler super.init?

Citation du langage de programmation Swift, qui répond à votre question:

«Le compilateur de Swift effectue quatre vérifications de sécurité utiles pour s'assurer que l'initialisation en deux phases est terminée sans erreur:»

Contrôle de sécurité 1 «Un initialiseur désigné doit s'assurer que toutes les« propriétés introduites par sa classe sont initialisées avant de déléguer jusqu'à un initialiseur de superclasse ».

Extrait de: Apple Inc. «The Swift Programming Language». iBooks. https://itunes.apple.com/us/book/swift-programming-language/id881256329?mt=11

Swift a une séquence d'opérations très claire et spécifique qui se fait dans les initialiseurs. Commençons par quelques exemples de base et progressons jusqu'à un cas général.

Prenons un objet A. Nous le définirons comme suit.

class A {
    var x: Int
    init(x: Int) {
        self.x = x
    }
}

Notez que A n'a pas de superclasse, il ne peut donc pas appeler une fonction super.init () car elle n'existe pas.

OK, alors maintenant, sous-classe A avec une nouvelle classe nommée B.

class B: A {
    var y: Int
    init(x: Int, y: Int) {
        self.y = y
        super.init(x: x)
    }
}

Il s'agit d'une dérogation à Objective-C, qui [super init]serait généralement appelée en premier avant toute autre chose. Ce n'est pas le cas à Swift. Vous êtes responsable de vous assurer que vos variables d'instance sont dans un état cohérent avant de faire quoi que ce soit d'autre, y compris les méthodes d'appel (qui inclut l'initialiseur de votre superclasse).

À partir des documents

Contrôle de sécurité 1

Un initialiseur désigné doit s'assurer que toutes les propriétés introduites par sa classe sont initialisées avant de déléguer jusqu'à un initialiseur de superclasse.

Pourquoi avons-nous besoin d'un contrôle de sécurité comme celui-ci?

Pour répondre à cela, nous allons parcourir le processus d'initialisation en un rien de temps.

Initialisation en deux phases

L'initialisation de classe dans Swift est un processus en deux phases. Dans la première phase, chaque propriété stockée se voit attribuer une valeur initiale par la classe qui l'a introduite. Une fois que l'état initial de chaque propriété stockée a été déterminé, la deuxième phase commence et chaque classe a la possibilité de personnaliser davantage ses propriétés stockées avant que la nouvelle instance ne soit considérée comme prête à l'emploi.

L'utilisation d'un processus d'initialisation en deux phases rend l'initialisation sûre, tout en offrant une flexibilité complète à chaque classe dans une hiérarchie de classes. L'initialisation en deux phases empêche d'accéder aux valeurs de propriété avant qu'elles ne soient initialisées et empêche que les valeurs de propriété soient définies sur une valeur différente par un autre initialiseur de manière inattendue.

Donc, pour vous assurer que le processus d'initialisation en deux étapes est effectué comme défini ci-dessus, il y a quatre contrôles de sécurité, l'un d'eux est,

Contrôle de sécurité 1

Un initialiseur désigné doit s'assurer que toutes les propriétés introduites par sa classe sont initialisées avant de déléguer jusqu'à un initialiseur de superclasse.

Or, l'initialisation en deux phases ne parle jamais d'ordre, mais ce contrôle de sécurité, introduit super.inità ordonner, après l'initialisation de toutes les propriétés.

Le contrôle de sécurité 1 peut sembler non pertinent, car l' initialisation en deux phases empêche d'accéder aux valeurs des propriétés avant qu'elles ne soient initialisées , sans ce contrôle de sécurité 1.

Comme dans cet exemple

class Shape {
    var name: String
    var sides : Int
    init(sides:Int, named: String) {
        self.sides = sides
        self.name = named
    }
}

class Triangle: Shape {
    var hypotenuse: Int
    init(hypotenuse:Int) {
        super.init(sides: 3, named: "Triangle") 
        self.hypotenuse = hypotenuse
    }
}

Triangle.inita initialisé, chaque propriété avant d'être utilisée. Donc, le contrôle de sécurité 1 ne semble pas pertinent,

Mais il pourrait y avoir un autre scénario, un peu complexe,

class Shape {
    var name: String
    var sides : Int
    init(sides:Int, named: String) {
        self.sides = sides
        self.name = named
        printShapeDescription()
    }
    func printShapeDescription() {
        print("Shape Name :\(self.name)")
        print("Sides :\(self.sides)")
    }
}

class Triangle: Shape {
    var hypotenuse: Int
    init(hypotenuse:Int) {
        self.hypotenuse = hypotenuse
        super.init(sides: 3, named: "Triangle")
    }

    override func printShapeDescription() {
        super.printShapeDescription()
        print("Hypotenuse :\(self.hypotenuse)")
    }
}

let triangle = Triangle(hypotenuse: 12)

Production :

Shape Name :Triangle
Sides :3
Hypotenuse :12

Ici, si nous avions appelé super.initavant de définir le hypotenuse, l' super.initappel aurait alors appelé le printShapeDescription()et puisque cela a été remplacé, il reviendrait d'abord à l'implémentation de la classe Triangle printShapeDescription(). La printShapeDescription()classe of Triangle accède à hypotenuseune propriété non facultative qui n'a pas encore été initialisée. Et cela n'est pas autorisé car l' initialisation en deux phases empêche l'accès aux valeurs des propriétés avant leur initialisation

Assurez-vous donc que l'initialisation en deux phases se fait comme défini, il doit y avoir un ordre spécifique d'appel super.init, et c'est-à-dire, après avoir initialisé toutes les propriétés introduites par selfclasse, nous avons donc besoin d'un contrôle de sécurité 1

Le "super.init ()" doit être appelé après avoir initialisé toutes vos variables d'instance.

Dans la vidéo "Intermediate Swift" d'Apple (vous pouvez la trouver sur la page de ressources vidéo pour les développeurs Apple https://developer.apple.com/videos/wwdc/2014/ ), vers 28 h 40, il est dit explicitement que tous les initialiseurs de la super classe doit être appelée APRÈS avoir initialisé vos variables d'instance.

Dans Objective-C, c'était l'inverse. Dans Swift, puisque toutes les propriétés doivent être initialisées avant d'être utilisées, nous devons d'abord initialiser les propriétés. Ceci est destiné à empêcher un appel à une fonction redéfinie à partir de la méthode "init ()" de la super classe, sans initialiser les propriétés au préalable.

La mise en œuvre de "Square" devrait donc être:

class Square: Shape {
    var sideLength: Double

    init(sideLength:Double, name:String) {
        self.sideLength = sideLength
        numberOfSides = 4
        super.init(name:name) // Correct position for "super.init()"
    }
    func area () -> Double {
        return sideLength * sideLength
    }
}

Désolé pour le formatage moche. Mettez simplement un caractère de question après la déclaration et tout ira bien. Une question indique au compilateur que la valeur est facultative.

class Square: Shape {
    var sideLength: Double?   // <=== like this ..

    init(sideLength:Double, name:String) {
        super.init(name:name) // Error here
        self.sideLength = sideLength
        numberOfSides = 4
    }
    func area () -> Double {
        return sideLength * sideLength
    }
}

Edit1:

Il existe une meilleure façon d'ignorer cette erreur. Selon le commentaire de jmaschad, il n'y a aucune raison d'utiliser facultatif dans votre cas car les optionnels ne sont pas confortables à utiliser et vous devez toujours vérifier si facultatif n'est pas nul avant d'y accéder. Il vous suffit donc d'initialiser le membre après la déclaration:

class Square: Shape {
    var sideLength: Double=Double()   

    init(sideLength:Double, name:String) {
        super.init(name:name)
        self.sideLength = sideLength
        numberOfSides = 4
    }
    func area () -> Double {
        return sideLength * sideLength
    }
}

Edit2:

Après deux inconvénients à cette réponse, j'ai trouvé un moyen encore meilleur. Si vous voulez que le membre de la classe soit initialisé dans votre constructeur, vous devez lui attribuer une valeur initiale à l'intérieur de contructor et avant l'appel de super.init (). Comme ça:

class Square: Shape {
    var sideLength: Double  

    init(sideLength:Double, name:String) {
        self.sideLength = sideLength   // <= before super.init call..
        super.init(name:name)
        numberOfSides = 4
    }
    func area () -> Double {
        return sideLength * sideLength
    }
}

Bonne chance pour apprendre Swift.

swift vous oblige à initialiser chaque var membre avant qu'il ne soit / ne soit jamais utilisé. Puisqu'il ne peut pas être sûr de ce qui se passe quand c'est le tour, il se trompe: mieux vaut prévenir que guérir

Edward,

Vous pouvez modifier le code dans votre exemple comme ceci:

var playerShip:PlayerShip!
var deltaPoint = CGPointZero

init(size: CGSize)
{
    super.init(size: size)
    playerLayerNode.addChild(playerShip)        
}

Ceci utilise une option implicitement déballée.

Dans la documentation, nous pouvons lire:

"Comme pour les options, si vous ne fournissez pas de valeur initiale lorsque vous déclarez une variable ou une propriété facultative implicitement non encapsulée, sa valeur par défaut est automatiquement nulle."

Swift ne vous permettra pas d'initialiser une super classe sans initialiser les propriétés, à l'inverse de l'Obj C. Vous devez donc initialiser toutes les propriétés avant d'appeler "super.init".

Veuillez vous rendre sur http://blog.scottlogic.com/2014/11/20/swift-initialisation.html . Il donne une belle explication à votre problème.

Ajoutez zéro à la fin de la déclaration.

// Must be nil or swift complains
var someProtocol:SomeProtocol? = nil

// Init the view
override init(frame: CGRect)
    super.init(frame: frame)
    ...

Cela a fonctionné pour mon cas, mais peut ne pas fonctionner pour le vôtre

Vous commencez juste dans le mauvais ordre.

     class Shape2 {
        var numberOfSides = 0
        var name: String
        init(name:String) {
            self.name = name
        }
        func simpleDescription() -> String {
            return "A shape with \(numberOfSides) sides."
        }
    }

    class Square2: Shape2 {
        var sideLength: Double

        init(sideLength:Double, name:String) {

            self.sideLength = sideLength
            super.init(name:name) // It should be behind "self.sideLength = sideLength"
            numberOfSides = 4
        }
        func area () -> Double {
            return sideLength * sideLength
        }
    }

Je vais probablement recevoir des downvotes, mais pour être honnête, la vie est plus facile de cette façon:

class CSListServerData<ListItem: CSJsonData>: CSServerData {
    var key: String!
    var type: ListItem.Type!
    var property: CSJsonDataList<ListItem>!

    func construct(_ key: String, _ type: ListItem.Type) -> Self {
        self.key = key
        self.type = type
        property = CSJsonDataList(self, type, key)
        return self
    }

    func construct(_ type: ListItem.Type) { construct("list", type) }

    var list: [ListItem] { property.list }
}

C'est une conception incroyablement stupide.

Considérez quelque chose comme ceci:

.
.
.
var playerShip:PlayerShip
var deltaPoint = CGPointZero

init(size: CGSize)
{
    super.init(size: size)
    playerShip = PlayerShip(pos: CGPointMake(self.size.width / 2.0, 100))
    playerLayerNode.addChild(playerShip)        
}
.
.
.

Ceci n'est pas valide, comme indiqué ci-dessus. Mais il en va de même:

.
.
.
var playerShip:PlayerShip = PlayerShip(pos: CGPointMake(self.size.width / 2.0, 100))
var deltaPoint = CGPointZero

init(size: CGSize)
{
    super.init(size: size)
    playerLayerNode.addChild(playerShip)        
}
.
.
.

Parce que «soi» n'a pas été initialisé.

J'espère sincèrement que ce bug sera bientôt corrigé.

(Oui, je sais que je pourrais créer un objet vide, puis définir la taille, mais c'est juste stupide).