Variabili di classe non ancora supportate

Inizio il mio progetto con un controller di visualizzazione divisa come controller di visualizzazione iniziale e lo avvio automaticamente dallo storyboard.

In genere, un'app con questa interfaccia utente ha uno e un solo controller di visualizzazione divisa come root, quindi creo una variabile statica nella sottoclasse e la imposto al termine dell'inizializzazione.

Quindi voglio provare questo comportamento con swift.

Ho letto la guida del linguaggio di programmazione Swift su iBook sulle proprietà del tipo (con parola chiave statica e di classe) e ho provato un pezzo di codice per il lavoro:

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

ma ho capito quando Xcode dice che la parola chiave class per le proprietà del tipo non era ancora supportata.

Avevi una soluzione per farlo?

Swift ora supporta le variabili statiche nelle classi. Questa non è esattamente la stessa di una variabile di classe (perché non sono ereditate dalle sottoclassi), ma ti avvicina molto:

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

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

X.x = 5

println(X.x)

Incorporare una struttura può funzionare bene come soluzione alternativa:

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 proprietà di tipo calcolato SomeClass.workaroundClassVariable può quindi essere utilizzata come se fosse una proprietà di tipo archiviato.

Sembra essere possibile dichiarare variabili con durata di archiviazione statica nell'ambito del file (come in C):

var sharedInstance: SplitViewController? = nil

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

Il mio metodo preferito è usare solo un ambito di file privato var al di fuori della classe e quindi implementare getter e setter di classe / statici:

private var _classVar: Int = 0;

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

A partire da Swift 1.2 (disponibile con Xcode 6.3b1 e successivi), staticle proprietà ei metodi di classe sono supportati.

class SomeClass
{
    static var someVariable: Int = 0
}

Utilizzando un modello singleton dispatch_once in Swift

Sembra essere la risposta migliore finora, evitando l'uso di una variabile globale.

Una soluzione abbastanza simile a var nell'ambito del file ma più personalizzabile e vicino al singleton consiste nell'usare una struttura che supporti la var statica come proprietà della 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, con la soluzione di Nikolai che fa il lavoro. Inserisco le mie modifiche in questo thread per informazioni

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

e ad esempio, nel mio appDelegate, posso accedere a questo metodo statico come questo

SplitViewController.sharedInstance()!.presentsWithGesture = false

La formulazione dell'errore implica fortemente che questa sarà una caratteristica della lingua in futuro.

Potresti voler ricorrere temporaneamente alla dichiarazione di una variabile di proprietà in Application Delegate e recuperarla da lì. Non è l'ideale, sicuramente un anti-pattern, ma ti darebbe un posto centrale per recuperare il UISplitViewControllerquando necessario.

Devi avvolgere le variabili di classe all'interno di una variabile struct interna

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

Prova questo:

class var instance: SplitViewController {
    return nil
}

Si chiama Type Property in Swift.

Si definiscono le proprietà del tipo con la parola chiave statica. Per le proprietà di tipo calcolate per i tipi di classe, è possibile utilizzare invece la parola chiave class per consentire alle sottoclassi di sovrascrivere l'implementazione della superclasse. L'esempio seguente mostra la sintassi per le proprietà del tipo archiviate e calcolate:

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

Leggi di più al link sottostante,

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