Variables de classe non encore prises en charge

Je commence mon projet avec un contrôleur de vue fractionnée comme contrôleur de vue initial et le démarre automatiquement à partir du storyboard.

En règle générale, une application avec cette interface utilisateur a un et un seul contrôleur de vue fractionnée en tant que racine, donc je crée une variable statique dans la sous-classe et la définit lorsque l'initialisation a été effectuée.

Je veux donc essayer ce comportement avec rapidité.

J'ai lu le guide du langage de programmation Swift sur iBook à propos des propriétés de type (avec mot-clé statique et de classe) et j'ai essayé un morceau de code pour le travail:

import UIKit

class SplitViewController: UISplitViewController {

    class func sharedInstance() -> SplitViewController {
        return SplitViewController.instance
    }

    class let instance: SplitViewController = nil

    init(nibName nibNameOrNil: String?, bundle nibBundleOrNil: NSBundle?) {
        super.init(nibName: nibNameOrNil, bundle: nibBundleOrNil)
        self.initialization()
    }

    init(coder aDecoder: NSCoder!) {
        super.init(coder: aDecoder);
        self.initialization()
    }

    func initialization() {
        SplitViewController.instance = self;
    }
}

mais j'ai compris quand Xcode a dit que le mot-clé de classe pour les propriétés de type n'était pas encore pris en charge.

Aviez-vous une solution pour cela?

Swift prend désormais en charge les variables statiques dans les classes. Ce n'est pas exactement la même chose qu'une variable de classe (car elles ne sont pas héritées par des sous-classes), mais cela vous rapproche assez:

class X {
  static let y: Int = 4
  static var x: Int = 4
}

println(X.x)
println(X.y)

X.x = 5

println(X.x)

L'incorporation d'une structure peut très bien fonctionner comme solution de contournement:

class SomeClass
{
  // class var classVariable: Int = 0
  // "Class variables not yet supported." Weird.

  // Workaround:
  private struct SubStruct { static var staticVariable: Int = 0 }

  class var workaroundClassVariable: Int
  {
    get { return SubStruct.staticVariable }
    set { SubStruct.staticVariable = newValue }
  }
}

La propriété de type calculé SomeClass.workaroundClassVariable peut ensuite être utilisée comme s'il s'agissait d'une propriété de type stocké.

Il semble possible de déclarer des variables avec une durée de stockage statique dans la portée du fichier (comme en C):

var sharedInstance: SplitViewController? = nil

class SplitViewController: UISplitViewController {
    ....
    func initialization() {
        sharedInstance = self
    }
}

Ma méthode préférée consiste simplement à utiliser une variable de portée de fichier privé en dehors de la classe, puis à implémenter des getters et des setters de classe / statique:

private var _classVar: Int = 0;

class SomeClass
{
    public class var classVar: Int
    {
        get { return _classVar }
        set { _classVar = newValue }
    }
}

Depuis Swift 1.2 (disponible avec Xcode 6.3b1 et les versions ultérieures), staticles propriétés de classe et les méthodes sont prises en charge.

class SomeClass
{
    static var someVariable: Int = 0
}

Utilisation d'un modèle singleton dispatch_once dans Swift

Semble être la meilleure réponse à ce jour, en évitant l'utilisation d'une variable globale.

Une solution assez similaire à var dans la portée du fichier mais plus personnalisable et proche du singleton consiste à utiliser une structure qui prend en charge var statique comme propriété de classe

struct PersonSharedData {
    static var backstore = ""
    var data: String {
    get { return PersonSharedData.backstore }
    set { PersonSharedData.backstore = newValue }
    }
}

class Person {
    var shared=PersonSharedData() //<< pseudo class var
    var family: String {
        get { return shared.data }
        set { shared.data=newValue }
    }
    var firstname = ""
    var lastname = ""
    var sexe: Sexe = .Unknown
}

Ok, avec la solution de Nikolai qui fait le travail. Je poste mes modifications dans ce fil pour information

var instance: SplitViewController? = nil

class SplitViewController: UISplitViewController {

    class func sharedInstance() -> SplitViewController? {
        return instance;
    }

    init(nibName nibNameOrNil: String?, bundle nibBundleOrNil: NSBundle?) {
        super.init(nibName: nibNameOrNil, bundle: nibBundleOrNil)
        self.initialization()
    }

    init(coder aDecoder: NSCoder!) {
        super.init(coder: aDecoder);
        self.initialization()
    }

    func initialization() {
        instance = self
    }
}

et par exemple, dans mon appDelegate, je peux accéder à cette méthode statique comme celle-ci

SplitViewController.sharedInstance()!.presentsWithGesture = false

Le libellé de l'erreur implique fortement que ce sera une caractéristique du langage à l'avenir.

Vous souhaiterez peut-être recourir temporairement à la déclaration d'une variable de propriété dans le délégué d'application et à la récupérer à partir de là. Pas idéal, certainement un anti-modèle, mais vous donnerait un endroit central pour récupérer le UISplitViewControllersi nécessaire.

Vous devez envelopper les variables de classe dans une variable struct interne

class Store{
    var name:String
    var address:String
    var lat:Int
    var long:Int
    init(name:String, address:String, lat:Int, long:Int){
        self.name = name
        self.address = address
        self.lat = lat
        self.long=long
    }

    private struct FACTORY_INITIALIZED_FLAG { static var initialized: Bool = false
       static var  myStoreList:[Store]?
        static func getMyStoreList()->[Store]{
            if !initialized{
                println("INITIALIZING")
                myStoreList = [
                    Store(name: "Walmart", address: "abcd", lat: 10, long: 20),
                    Store(name: "JCPenny", address: "kjfnv", lat: 23, long: 34)
                ]
                initialized = true
            }
                return myStoreList!
    }
    }
}


var a = Store.FACTORY_INITIALIZED_FLAG.getMyStoreList()

var b = Store.FACTORY_INITIALIZED_FLAG.getMyStoreList()

// only prints INITIALIZING once

Essaye ça:

class var instance: SplitViewController {
    return nil
}

Il s'appelle Propriété de type dans Swift.

Vous définissez les propriétés de type avec le mot clé static. Pour les propriétés de type calculées pour les types de classe, vous pouvez utiliser le mot clé class à la place pour permettre aux sous-classes de remplacer l'implémentation de la superclasse. L'exemple ci-dessous montre la syntaxe des propriétés de type stockées et calculées:

struct SomeStructure {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        return 1
    }
}
enum SomeEnumeration {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        return 6
    }
}
class SomeClass {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        return 27
    }
    class var overrideableComputedTypeProperty: Int {
        return 107
    }
}

En savoir plus sur le lien ci-dessous,

https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Properties.html#//apple_ref/doc/uid/TP40014097-CH14-ID254