वर्ग चर अभी तक समर्थित नहीं हैं

Question 1

मैं अपनी परियोजना को प्रारंभिक दृश्य नियंत्रक के रूप में एक विभाजन दृश्य नियंत्रक के साथ शुरू करता हूं और इसे स्टोरीबोर्ड से स्वचालित रूप से शुरू करता हूं।

आम तौर पर, इस यूआई वाले ऐप में रूट के रूप में एक और केवल एक स्प्लिट व्यू कंट्रोलर होता है, इसलिए मैं ए बनाता हूं स्टैटिक वेरिएबल और इसे सेट करता जब इनिशियलाइजेशन किया गया था।

इसलिए मैं इस व्यवहार को तेजी के साथ करना चाहता हूं।

मैंने टाइपबुक (स्थिर और वर्ग कीवर्ड के साथ) और नौकरी के लिए कोड का एक टुकड़ा आज़माने के बारे में iBook पर स्विफ्ट प्रोग्रामिंग भाषा गाइड बुक पढ़ी:

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

लेकिन मुझे पता चला जब Xcode का कहना है कि प्रकार के गुणों के लिए वर्ग कीवर्ड अभी तक समर्थित नहीं था।

छवि में त्रुटि विस्तार

क्या आपके पास ऐसा करने का कोई उपाय है?

Question 2

स्विफ्ट के पास अब कक्षाओं में स्थिर चर के लिए समर्थन है। यह बिल्कुल एक वर्ग चर के समान नहीं है (क्योंकि वे उपवर्गों द्वारा विरासत में नहीं मिले हैं), लेकिन यह आपको बहुत करीब से मिलता है:

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

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

X.x = 5

println(X.x)

Question 3

एक संरचना को एम्बेड करना वर्कअराउंड के रूप में ठीक काम कर सकता है:

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

SomeClass.workaroundClassVariable कंप्यूटेड प्रकार की संपत्ति का उपयोग तब किया जा सकता है जैसे कि यह एक संग्रहीत प्रकार की संपत्ति थी।

Question 4

ऐसा लगता है कि फ़ाइल स्कोप में स्थिर भंडारण अवधि के साथ चर घोषित करना संभव है (जैसा कि C में है):

var sharedInstance: SplitViewController? = nil

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

Question 5

मेरा पसंदीदा तरीका सिर्फ कक्षा के बाहर एक निजी फ़ाइल स्कोप संस्करण का उपयोग करना है और फिर क्लास / स्टैटिक गेटर्स और सेटर को लागू करना है:

private var _classVar: Int = 0;

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

Question 6

स्विफ्ट 1.2 (Xcode 6.3b1 और उसके बाद के साथ उपलब्ध) के रूप में, staticवर्ग गुणों और विधियों का समर्थन किया जाता है।

class SomeClass
{
    static var someVariable: Int = 0
}

Question 7

स्विफ्ट में एक डिस्पैच_ऑनस सिंगलटन मॉडल का उपयोग करना

एक वैश्विक चर के उपयोग से बचने के लिए अब तक का सबसे अच्छा उत्तर लगता है।

Question 8

फ़ाइल स्कोप में संस्करण की तुलना में पर्याप्त समाधान, लेकिन अधिक अनुकूलन योग्य और सिंगलटन के पास एक ऐसी संरचना का उपयोग करना है जो क्लास की संपत्ति के रूप में स्थिर संस्करण का समर्थन करता है

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
}

Question 9

ठीक है, निकोलाई के समाधान के साथ जो काम करते हैं। मैं जानकारी के लिए इस धागे में अपने परिवर्तन पोस्ट करता हूं

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

और उदाहरण के लिए, अपने ऐपडेलगेट में, मैं इस तरह से इस स्थिर विधि का उपयोग कर सकता हूं

SplitViewController.sharedInstance()!.presentsWithGesture = false

Question 10

त्रुटि में शब्दों का तात्पर्य यह है कि यह भविष्य में एक भाषा सुविधा होगी।

आप अनुप्रयोग प्रतिनिधि में एक संपत्ति चर घोषित करने के लिए अस्थायी रूप से सहारा लेना चाहते हैं और इसे वहां से पुनः प्राप्त कर सकते हैं। आदर्श नहीं, निश्चित रूप से एक विरोधी पैटर्न है, लेकिन आपको UISplitViewControllerजरूरत पड़ने पर पुनः प्राप्त करने के लिए एक केंद्रीय स्थान प्रदान करेगा ।

Question 11

आपको एक आंतरिक संरचना चर के अंदर वर्ग चर को लपेटना होगा

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

Question 12

इसे इस्तेमाल करे:

class var instance: SplitViewController {
    return nil
}

Question 13

इसे स्विफ्ट में टाइप प्रॉपर्टी कहा जाता है ।

आप स्थैतिक कीवर्ड के साथ प्रकार गुण परिभाषित करते हैं। वर्ग प्रकारों के लिए गणना प्रकार के गुणों के लिए, आप उपवर्गों को सुपरक्लास के कार्यान्वयन को ओवरराइड करने की अनुमति देने के बजाय वर्ग कीवर्ड का उपयोग कर सकते हैं। नीचे दिया गया उदाहरण संग्रहीत और गणना प्रकार गुणों के लिए सिंटैक्स दिखाता है:

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

नीचे दिए गए लिंक पर और पढ़ें

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