Swift Language
चर और गुण

टिप्पणियों

एक परिवर्तनशील बनाना

var साथ एक नया वैरिएबल घोषित करें, उसके बाद एक नाम, प्रकार, और मान:

var num: Int = 10

चर अपने मूल्यों को बदल सकते हैं:

num = 20 // num now equals 20

जब तक वे let परिभाषित न हों:

let num: Int = 10 // num cannot change

स्विफ्ट, चर के प्रकार को प्रभावित करता है, इसलिए आपको हमेशा चर प्रकार घोषित करने की आवश्यकता नहीं है:

let ten = 10 // num is an Int
let pi = 3.14 // pi is a Double
let floatPi: Float = 3.14 // floatPi is a Float

चर नाम अक्षरों और संख्याओं तक सीमित नहीं हैं - उनमें अधिकांश अन्य यूनिकोड वर्ण भी हो सकते हैं, हालांकि कुछ प्रतिबंध हैं

लगातार और चर नामों में व्हॉट्सएप वर्ण, गणितीय प्रतीक, तीर, निजी-उपयोग (या अमान्य) यूनिकोड कोड बिंदु, या लाइन- और बॉक्स-ड्राइंग वर्ण नहीं हो सकते। न ही वे एक संख्या से शुरू कर सकते हैं

_{स्रोत डेवलपर .apple.com}

var π: Double = 3.14159
var 🍎🍏: String = "Apples"

संपत्ति मूल बातें

गुण एक में जोड़ा जा सकता वर्ग या struct (तकनीकी रूप से enums भी देख "परिकलित गुण" उदाहरण)। ये ऐसे मूल्य जोड़ते हैं जो कक्षाओं / संरचनाओं के उदाहरणों के साथ जुड़ते हैं:

class Dog {
    var name = ""
}

उपरोक्त मामले में, Dog उदाहरणों में एक संपत्ति है जिसका name टाइप String । संपत्ति को Dog उदाहरणों पर पहुँचा और संशोधित किया जा सकता है:

let myDog = Dog()
myDog.name = "Doggy" // myDog's name is now "Doggy"

इस प्रकार के गुणों को संग्रहीत गुण माना जाता है , क्योंकि वे किसी वस्तु पर कुछ संग्रहीत करते हैं और उसकी स्मृति को प्रभावित करते हैं।

आलसी संग्रहीत गुण

आलसी संग्रहित गुणों में ऐसे मान होते हैं जिनकी गणना पहली पहुंच तक नहीं होती है। यह मेमोरी सेविंग के लिए उपयोगी है जब चर की गणना कम्प्यूटेशनल रूप से महंगी होती है। आप के साथ एक आलसी संपत्ति घोषित lazy :

lazy var veryExpensiveVariable = expensiveMethod()

अक्सर इसे एक क्लोजर के रिटर्न वैल्यू को सौंपा जाता है:

lazy var veryExpensiveString = { () -> String in
    var str = expensiveStrFetch()
    str.expensiveManipulation(integer: arc4random_uniform(5))
    return str
}()

आलसी संग्रहीत गुणों को var साथ घोषित किया जाना चाहिए।

संगणित गुण

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

var pi = 3.14

class Circle {
    var radius = 0.0
    var circumference: Double {
        get {
            return pi * radius * 2
        }
        set {
            radius = newValue / pi / 2
        }
    }
}

let circle = Circle()
circle.radius = 1
print(circle.circumference) // Prints "6.28"
circle.circumference = 14
print(circle.radius) // Prints "2.229..."

केवल पढ़ने योग्य संपत्तियों को अभी भी एक var साथ घोषित किया गया है:

var circumference: Double {
    get {
        return pi * radius * 2
    }
}

केवल-निकाली गई संपत्तियों को get करने के लिए छोटा किया जा सकता है:

var circumference: Double {
    return pi * radius * 2
}

स्थानीय और वैश्विक चर

स्थानीय चर किसी फ़ंक्शन, पद्धति या बंद होने के भीतर परिभाषित किए जाते हैं:

func printSomething() {
    let localString = "I'm local!"
    print(localString)
}

func printSomethingAgain() {
    print(localString) // error
}

वैश्विक चर किसी फ़ंक्शन, विधि या बंद होने के बाहर परिभाषित होते हैं, और एक प्रकार के भीतर परिभाषित नहीं होते हैं (सभी कोष्ठक के बाहर सोचो)। उनका उपयोग कहीं भी किया जा सकता है:

let globalString = "I'm global!"
print(globalString)

func useGlobalString() {
    print(globalString) // works!
}

for i in 0..<2 {
    print(globalString) // works!
}

class GlobalStringUser {
    var computeGlobalString {
        return globalString // works!
    }
}

वैश्विक चर को आलसी के रूप में परिभाषित किया जाता है ("आलसी गुण" उदाहरण देखें)।

प्रकार के गुण

प्रकार गुण गुण प्रकार पर ही होते हैं, उदाहरण पर नहीं। वे संग्रहीत या गणना किए गए गुणों दोनों हो सकते हैं। आप static साथ एक प्रकार की संपत्ति घोषित करते हैं:

struct Dog {
    static var noise = "Bark!"
}

print(Dog.noise) // Prints "Bark!"

एक कक्षा में, आप इसे static बनाने static लिए static बजाय class कीवर्ड का उपयोग कर सकते हैं। हालाँकि, आप इसे केवल संगणित गुणों पर लागू कर सकते हैं:

class Animal {
    class var noise: String {
        return "Animal noise!"
    }
}
class Pig: Animal {
    override class var noise: String {
        return "Oink oink!"
    }
}

यह अक्सर सिंगलटन पैटर्न के साथ प्रयोग किया जाता है।

संपत्ति पर्यवेक्षकों

प्रॉपर्टी ऑब्जर्वर किसी प्रॉपर्टी की वैल्यू में बदलाव का जवाब देते हैं।

var myProperty = 5 {
    willSet {
        print("Will set to \(newValue). It was previously \(myProperty)")
    }
    didSet {
        print("Did set to \(myProperty). It was previously \(oldValue)")
    }
}
myProperty = 6
// prints: Will set to 6, It was previously 5
// prints: Did set to 6. It was previously 5

• willSet सेट को myProperty सेट होने से पहले कहा जाता है। नया मान newValue रूप में उपलब्ध है, और पुराना मान अभी भी myProperty रूप में उपलब्ध है।
• didSet सेट होने के बाद myProperty कहा जाता है। पुराने मूल्य के रूप में उपलब्ध है oldValue , और नए मूल्य के रूप में अब उपलब्ध है myProperty ।

नोट: didSet और willSet को निम्नलिखित मामलों में नहीं बुलाया जाएगा:

• एक प्रारंभिक मूल्य निर्दिष्ट करना
• चर को अपने स्वयं के didSet या willSet संशोधित करना

• के लिए पैरामीटर नाम oldValue और newValue की didSet और willSet भी पठनीयता को बढ़ाने के लिए घोषित किया जा सकता:

var myFontSize = 10 {
    willSet(newFontSize) {
        print("Will set font to \(newFontSize), it was \(myFontSize)")
    }
    didSet(oldFontSize) {
        print("Did set font to \(myFontSize), it was \(oldFontSize)")
    }
}

सावधानी: जब इसे सेटर पैरामीटर नामों की घोषणा करने का समर्थन किया जाता है, तो किसी को नाम न मिलाने के लिए सतर्क रहना चाहिए:

• willSet(oldValue) और didSet(newValue) पूरी तरह से कानूनी हैं, लेकिन आपके कोड के पाठकों को काफी भ्रमित करेंगे।