कैसे तेजी से एक वर्ग में स्थिर स्थिर परिभाषित करने के लिए

Question

मेरे कार्य में ये परिभाषाएँ हैं जो काम करती हैं

class MyClass {
    func myFunc() {
        let testStr = "test"
        let testStrLen = countElements(testStr)
    }
}

लेकिन अगर मैं 'testStr' और 'testStrLen' को कक्षा के स्तर पर ले जाऊं, तो यह संकलन नहीं करेगा। इसने कहा कि 'MyClass.Type में' testStr 'नाम का कोई सदस्य नहीं है।

class MyClass {
    let testStr = "test"
    let testStrLen = countElements(testStr)

    func myFunc() {

    }
}

मैं इसे कैसे ठीक करूं? मैं हर बार एक निरंतर 'परीक्षण' के लेन की गिनती के लिए जुर्माना का भुगतान नहीं करना चाहता।

नीचे टिप्पणी की मेरी समझ के आधार पर, मुझे यह करने की आवश्यकता है:

class MyClass {
    let testStr = "test"
    let testStrLen = countElements("test")

    func myFunc() {

    }
}

क्या एक ऐसा तरीका है जिसे मुझे दो बार "टेस्ट" टाइप / दर्ज करने की आवश्यकता नहीं है? धन्यवाद।

Comments

ViewControl.Type के संभावित डुप्लिकेट में एक सदस्य का नाम नहीं है (किसी संपत्ति का प्रारंभिक मूल्य किसी अन्य संपत्ति पर निर्भर नहीं कर सकता है।)

— मार्टिन आर।

एक CGRectMake में एक्स और वाई चेंज के संभावित डुप्लिकेट (आलसी संपत्ति का उपयोग करके एक अच्छा समाधान के साथ)

— मार्टिन आर

"क्या एक ऐसा तरीका है जिसे मुझे दो बार" टेस्ट "टाइप / दर्ज करने की आवश्यकता नहीं है?" - हाँ। TestStrLen के आरंभीकरण को एक init पद्धति में ले जाएँ (जैसा कि पहले संभव डुप्लिकेट के उत्तर में सुझाया गया है), या एक आलसी इनिशियलाइज़ेशन का उपयोग करें (जैसा कि दूसरे संभावित डुप्लिकेट के उत्तर में सुझाया गया है)।

— मार्टिन आर।

Answer 1

शायद स्विफ्ट में एक वर्ग के लिए स्थिरांक घोषित करने के लिए एक अच्छा मुहावरा सिर्फ निम्नलिखित जैसे MyClassConstants नामक एक संरचना का उपयोग करना है।

struct MyClassConstants{
    static let testStr = "test"
    static let testStrLength = countElements(testStr)

    static let arrayOfTests: [String] = ["foo", "bar", testStr]
}

इस तरह से आपके कंस्टेंट को विश्व स्तर पर तैरने के बजाय एक घोषित निर्माण के भीतर बंद कर दिया जाएगा।

अपडेट करें

स्थैतिक सरणी इनिशियलाइज़ेशन के बारे में पूछने वाली टिप्पणी के जवाब में मैंने एक स्थिर सरणी स्थिरांक जोड़ा है। "द स्विफ्ट प्रोग्रामिंग लैंग्वेज" में ऐरे लिटरल्स देखें ।

ध्यान दें कि दोनों स्ट्रिंग शाब्दिक और स्ट्रिंग स्थिरांक का उपयोग सरणी को आरंभीकृत करने के लिए किया जा सकता है। हालाँकि, सरणी प्रकार ज्ञात है कि पूर्णांक स्थिरांक का testStrLengthउपयोग सरणी आरंभीकरण में नहीं किया जा सकता है।

Comments

क्या आप इसके बजाय स्थिरांक को स्थिर निजी घोषित नहीं कर सकते थे? क्या वे अब वैश्विक नहीं होंगे?

— सेहटी

धड़कन का उपयोग करते हुए .Ravalue के रूप में मैं enum का उपयोग कर रहा था

— डॉग कॉफ़ी

यह सबसे अच्छा समाधान नहीं होगा यदि कोड का उपयोग ऑब्जेक्टिव C से भी किया जाए, क्योंकि Swift के स्ट्रक्चर्स का ऑब्जेक्टिव C में अनुवाद नहीं किया गया है

— mbpro

staticमें Structऔर Classतों में स्थिरांक घोषित करने में क्या अंतर है ?

— जौजी

@YOUNG स्विफ्ट 2.2 एनुमरेशन काम कर सकता है, लेकिन आम तौर पर सामान्य रूप से सिर्फ समूह स्थिरांक की तुलना में एक मजबूत सिमेंटिक एसोसिएशन होता है। लिंक में, स्विफ्ट एनम में संबद्ध मूल्यों और कच्चे मूल्यों दोनों की सुविधा है। आप कच्चे मूल्यों का उपयोग कर सकते हैं, लेकिन सिंटैक्स का MyClassConstants.testStr.rawValueउपयोग मूल्य तक पहुंचना है, जो सिंटैक्टिक रूप से अनुकूल नहीं है MyClassConstants.testStr।

— मार्टिन वूल्स्टनहुलमे

Answer 2

@ मार्टिन के जवाब में जोड़ ...

यदि कोई एप्लिकेशन स्तर की निरंतर फ़ाइल रखने की योजना बना रहा है, तो आप निरंतर को उनके प्रकार या प्रकृति के आधार पर समूहित कर सकते हैं

struct Constants {
    struct MixpanelConstants {
        static let activeScreen = "Active Screen";
    }
    struct CrashlyticsConstants {
        static let userType = "User Type";
    }
}

कॉल करें: Constants.MixpanelConstants.activeScreen

अद्यतन 5/5/2019 (विषय से हटकर लेकिन)

कुछ कोड दिशानिर्देशों को पढ़ने के बाद और व्यक्तिगत अनुभवों से ऐसा लगता है कि कुछ कारणों से वैश्विक स्थिरांक के भंडारण के लिए सबसे अच्छा तरीका नहीं है। विशेष रूप से उपरोक्त कोड संरचना के आरंभीकरण को नहीं रोकता है। हम कुछ बॉयलरप्लेट कोड जोड़कर इसे प्राप्त कर सकते हैं लेकिन एक बेहतर तरीका है

enums

एक अधिक सुरक्षित और स्पष्ट प्रतिनिधित्व के साथ एक एनम का उपयोग करके प्राप्त किया जा सकता है

enum Constants {
    enum MixpanelConstants: String {
        case activeScreen = "Active Screen";
    }
    enum CrashlyticsConstants: String {
        case userType = "User Type";
    }
}

print(Constants.MixpanelConstants.activeScreen.rawValue)

Comments

धन्यवाद। मुझे यह पसंद है, संरचना के माध्यम से स्थिरांक का एक सुरुचिपूर्ण तरीका प्रदान करता है।

— अभिजीत

अधिक उदाहरणों के साथ मैंने यहां एक बेहतर दृष्टिकोण जोड़ा है

— अनीश पराजुली '

Answer 3

यदि मैं आपके प्रश्न को सही ढंग से समझता हूं, तो आप पूछ रहे हैं कि आप कक्षा स्तर स्थिरांक (स्थैतिक - सी ++ परिच्छेद में) कैसे बना सकते हैं, ताकि आप क) हर उदाहरण में ओवरहेड को दोहराएं नहीं, और बी को फिर से जुटना होगा जो अन्यथा स्थिर है।

भाषा विकसित हुई है - जैसा कि हर पाठक जानता है, लेकिन जैसा कि मैंने Xcode 6.3.1 में इसका परीक्षण किया है, इसका समाधान है:

import Swift

class MyClass {
    static let testStr = "test"
    static let testStrLen = count(testStr)

    init() {
        println("There are \(MyClass.testStrLen) characters in \(MyClass.testStr)")
    }
}

let a = MyClass()

// -> There are 4 characters in test

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

Answer 4

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

let testStr = "test"
let testStrLen = countElements(testStr)

class MyClass {
    func myFunc() {
    }
}

यदि आप चाहते हैं कि इसके बजाय उदाहरण गुण हों, तो आप लंबाई के लिए एक आलसी संग्रहित संपत्ति का उपयोग कर सकते हैं - यह केवल पहली बार प्राप्त होने पर मूल्यांकन किया जाएगा, इसलिए आप इसे बार-बार कंप्यूटिंग नहीं करेंगे।

class MyClass {
    let testStr: String = "test"
    lazy var testStrLen: Int = countElements(self.testStr)

    func myFunc() {
    }
}

Comments

+1 बहुत बुरा लगता है फिर भी इन वैश्विक चरों की तुलना में बेहतर तरीका नहीं है।

— Drux

मुझे पता है कि यह इस समय एक भाषा बाधा है, लेकिन मैं हर कीमत पर ग्लोबल्स का उपयोग करने से बचना चाहूंगा। मुझे लगता है कि ClassNameConstants जैसी संरचना वाले कंटेनर w / कुछ का उपयोग करना अब के लिए एक बेहतर दृष्टिकोण होगा।

— जोरायर

Answer 5

कम्प्यूटेड गुणों का उपयोग करने के बारे में क्या?

class MyClass {
  class var myConstant: String { return "What is Love? Baby don't hurt me" }
}

MyClass.myConstant

Answer 6

कुछ लोग चाहते हैं कि कुछ वर्ग के लोग सार्वजनिक हों जबकि अन्य निजी हों।

निजी कीवर्ड का उपयोग उसी स्विफ्ट फ़ाइल के भीतर स्थिरांक के दायरे को सीमित करने के लिए किया जा सकता है।

class MyClass {

struct Constants {

    static let testStr = "test"
    static let testStrLen = testStr.characters.count

    //testInt will not be accessable by other classes in different swift files
    private static let testInt = 1
}

func ownFunction()
{

    var newInt = Constants.testInt + 1

    print("Print testStr=\(Constants.testStr)")
}

}

अन्य वर्ग नीचे की तरह अपने वर्ग के स्थिरांक का उपयोग करने में सक्षम होंगे

class MyClass2
{

func accessOtherConstants()
{
    print("MyClass's testStr=\(MyClass.Constants.testStr)")
}

} 

Answer 7

खेल के मैदान पर कोशिश की

class MyClass {


struct Constants {

    static let testStr = "test"
    static let testStrLen = testStr.characters.count

    //testInt will not be accessable by other classes in different swift files
    private static let testInt = 1

    static func singletonFunction()
    {
        //accessable
        print("Print singletonFunction testInt=\(testInt)")

        var newInt = testStrLen
        newInt = newInt + 1
        print("Print singletonFunction testStr=\(testStr)")
    }
}

func ownFunction() {
    //not accessable
    //var newInt1 = Constants.testInt + 1

    var newInt2 = Constants.testStrLen
    newInt2 = newInt2 + 1
    print("Print ownFunction testStr=\(Constants.testStr)")
    print("Print ownFunction newInt2=\(newInt2)")
}
}


let newInt = MyClass.Constants.testStrLen
print("Print testStr=\(MyClass.Constants.testStr)")
print("Print testInt=\(newInt)")


let myClass = MyClass()
myClass.ownFunction()
MyClass.Constants.singletonFunction()

Comments

यह प्रश्न कैसे संबंधित है?

— फ्रेंकलिन यू