Klassenvariablen werden noch nicht unterstützt

Ich beginne mein Projekt mit einem Split View Controller als Initial View Controller und starte es automatisch vom Storyboard aus.

Im Allgemeinen hat eine App mit dieser Benutzeroberfläche nur einen Split-View-Controller als Root. Daher erstelle ich eine statische Variable in der Unterklasse und lege sie fest, wenn die Initialisierung abgeschlossen ist.

Also möchte ich dieses Verhalten schnell ausprobieren.

Ich habe das Swift-Programmiersprachenhandbuch auf iBook über Typeigenschaften (mit statischem Schlüsselwort und Klassenschlüsselwort) gelesen und versucht, einen Code für den Job zu finden:

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

Aber ich habe herausgefunden, wann Xcode sagt, dass das Klassenschlüsselwort für Typeneigenschaften noch nicht unterstützt wird.

Hattest du eine Lösung dafür?

Swift unterstützt jetzt statische Variablen in Klassen. Dies ist nicht genau das Gleiche wie eine Klassenvariable (da sie nicht von Unterklassen geerbt werden), aber es bringt Sie ziemlich nahe:

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

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

X.x = 5

println(X.x)

Das Einbetten einer Struktur kann als Problemumgehung problemlos funktionieren:

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

Die berechnete Typ-Eigenschaft SomeClass.workaroundClassVariable kann dann so verwendet werden, als wäre sie eine gespeicherte Typ-Eigenschaft.

Es scheint möglich zu sein, Variablen mit statischer Speicherdauer im Dateibereich zu deklarieren (wie in C):

var sharedInstance: SplitViewController? = nil

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

Meine bevorzugte Methode besteht darin, nur eine private Dateibereichsvariable außerhalb der Klasse zu verwenden und dann klassen- / statische Getter und Setter zu implementieren:

private var _classVar: Int = 0;

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

Ab Swift 1.2 (verfügbar mit Xcode 6.3b1 und höher) werden staticKlasseneigenschaften und -methoden unterstützt.

class SomeClass
{
    static var someVariable: Int = 0
}

Verwenden eines dispatch_once-Singleton-Modells in Swift

Scheint die bisher beste Antwort zu sein, wobei die Verwendung einer globalen Variablen vermieden wird.

Eine Lösung, die im Dateibereich ähnlich wie var ist, jedoch anpassbarer und in der Nähe von Singleton ist, besteht darin, eine Struktur zu verwenden, die statische var als Eigenschaft der Klasse unterstützt

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, mit der Lösung von Nikolai, die die Arbeit macht. Ich poste meine Änderungen in diesem Thread zur 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
    }
}

In meinem appDelegate kann ich beispielsweise auf diese statische Methode zugreifen

SplitViewController.sharedInstance()!.presentsWithGesture = false

Der Wortlaut des Fehlers impliziert stark, dass dies in Zukunft ein Sprachmerkmal sein wird.

Möglicherweise möchten Sie vorübergehend eine Eigenschaftsvariable im Anwendungsdelegierten deklarieren und von dort abrufen. Nicht ideal, definitiv ein Anti-Muster, aber es würde Ihnen einen zentralen Ort geben, an dem Sie das UISplitViewControllerbei Bedarf abrufen können.

Sie müssen die Klassenvariablen in eine innere Strukturvariable einschließen

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

Versuche dies:

class var instance: SplitViewController {
    return nil
}

In Swift heißt es Type Property .

Sie definieren Typeneigenschaften mit dem Schlüsselwort static. Für berechnete Typeneigenschaften für Klassentypen können Sie stattdessen das Schlüsselwort class verwenden, damit Unterklassen die Implementierung der Oberklasse überschreiben können. Das folgende Beispiel zeigt die Syntax für gespeicherte und berechnete Typeneigenschaften:

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

Lesen Sie mehr unter dem Link unten,

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