Variables de clase aún no admitidas

Comienzo mi proyecto con un controlador de vista dividida como controlador de vista inicial y lo inicio automáticamente desde el guión gráfico.

Generalmente, una aplicación con esta interfaz de usuario tiene uno y solo un controlador de vista dividida como raíz, por lo que creo una variable estática en la subclase y la configuro cuando se realizó la inicialización.

Así que quiero probar este comportamiento con rapidez.

Leí la guía del lenguaje de programación Swift en el iBook sobre las propiedades de tipo (con palabras clave estáticas y de clase) y probé un fragmento de código para el trabajo:

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

pero descubrí cuando Xcode dice que la palabra clave de clase para las propiedades de tipo aún no es compatible.

¿Tenías una solución para hacer esto?

Swift ahora tiene soporte para variables estáticas en clases. Esto no es exactamente lo mismo que una variable de clase (porque no las heredan las subclases), pero te acerca bastante:

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

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

X.x = 5

println(X.x)

Incrustar una estructura puede funcionar bien como solución 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 propiedad de tipo calculado SomeClass.workaroundClassVariable se puede utilizar como si fuera una propiedad de tipo almacenada.

Parece ser posible declarar variables con duración de almacenamiento estático en el alcance del archivo (como en C):

var sharedInstance: SplitViewController? = nil

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

Mi método preferido es simplemente usar un ámbito de archivo privado var fuera de la clase y luego implementar captadores y definidores de clase / estáticos:

private var _classVar: Int = 0;

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

A partir de Swift 1.2 (disponible con Xcode 6.3b1 y posteriores), staticse admiten las propiedades y métodos de clase.

class SomeClass
{
    static var someVariable: Int = 0
}

Usando un modelo de singleton dispatch_once en Swift

Parece ser la mejor respuesta hasta ahora, evitando el uso de una variable global.

Una solución lo suficientemente similar a var en el alcance del archivo pero más personalizable y cercana al singleton es usar una estructura que admita var estática como propiedad de la clase

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 solución de Nikolai que hace el trabajo. Publico mis cambios en este hilo para obtener información.

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

y por ejemplo, en mi appDelegate, puedo acceder a este método estático como este

SplitViewController.sharedInstance()!.presentsWithGesture = false

La redacción del error implica en gran medida que será una característica del idioma en el futuro.

Es posible que desee recurrir temporalmente a declarar una variable de propiedad en el Delegado de aplicación y recuperarla desde allí. No es ideal, definitivamente un anti-patrón, pero le daría un lugar central para recuperarlo UISplitViewControllercuando sea necesario.

Tienes que envolver las variables de clase dentro de una variable de estructura 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

Prueba esto:

class var instance: SplitViewController {
    return nil
}

Se llama Propiedad de tipo en Swift.

Las propiedades de tipo se definen con la palabra clave estática. Para propiedades de tipo calculado para tipos de clase, puede usar la palabra clave class en su lugar para permitir que las subclases anulen la implementación de la superclase. El siguiente ejemplo muestra la sintaxis de las propiedades de tipo almacenadas y calculadas:

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

Lea más en el enlace a continuación,

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