road - swift vxi




तेजी से 'चलो' और 'var` के बीच क्या अंतर है? (18)

"एक चर बनाने के लिए स्थिर और var बनाने के लिए प्रयोग करें"

से उद्धरण: ऐप्पल इंक "स्विफ्ट प्रोग्रामिंग भाषा।" IBooks। https://itun.es/us/jEUH0.l

ऐप्पल की स्विफ्ट भाषा में let और var बीच क्या अंतर है?

मेरी समझ में, यह एक संकलित भाषा है लेकिन यह संकलन समय पर प्रकार की जांच नहीं करता है। यह मुझे उलझन में डाल देता है। कंपाइलर प्रकार त्रुटि के बारे में कैसे जानता है? यदि कंपाइलर प्रकार की जांच नहीं करता है, तो क्या यह उत्पादन वातावरण में कोई समस्या नहीं है?


Var के मामले में एक मूल्य को फिर से सौंप दिया जा सकता है

 //Variables
 var age = 42
 println(age) //Will print 42
 age = 90
 println(age) //Will Print 90

** newAge स्थिरता को नए मान पर पुन: असाइन नहीं किया जा सकता है। ऐसा करने का प्रयास करने से संकलन समय त्रुटि होगी **

//Constants
let newAge = 92 //Declaring a constant using let
println(newAge) //Will print 92.

उत्परिवर्तन / अनावश्यकता धारणा द्वारा इस अंतर को बताने के लिए यह बेहतर हो सकता है कि ऑब्जेक्ट्स स्पेस में मूल्यों और उदाहरणों में परिवर्तनशीलता का सही प्रतिमान है जो केवल "निरंतर / परिवर्तनीय" सामान्य धारणाओं से बड़ा है। और इसके अलावा यह उद्देश्य सी दृष्टिकोण के करीब है।

let aInt = 1
// or
let aPerson = Person(name:Foo, first:Bar)

एक मान परिभाषित करें और एक उदाहरण असंभव है

var aInt = 1
// or
var aPerson = Person(name:Foo, first:Bar)

परिवर्तनीय / मटेबल मूल्य और उदाहरण परिभाषित करें


एक अच्छा जवाब मिला उम्मीद है कि यह मदद कर सकता है :)


कीवर्ड var का प्रयोग वैरिएबल को परिभाषित करने के लिए किया जाता है जिसका मूल्य आप आसानी से इस तरह बदल सकते हैं:

var no1 = 1 // declaring the variable 
no1 = 2 // changing the value since it is defined as a variable not a constant

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

let no2 = 5 // declaring no2 as a constant
no2 = 8 // this will give an error as you cannot change the value of a constant 

कीवर्ड को निरंतर परिभाषित करने दें

let myNum = 7

तो बाद में मेरा नाम बदला नहीं जा सकता है;

लेकिन var एक सामान्य चर परिभाषित करता है।

स्थिरांक के मान को संकलित समय पर ज्ञात करने की आवश्यकता नहीं है, लेकिन आपको इसे एक बार एक मान असाइन करना होगा।

आप यूनिकोड वर्णों सहित निरंतर और परिवर्तनीय नामों के लिए लगभग किसी भी चरित्र का उपयोग कर सकते हैं;

जैसे

var x = 7 // here x is instantiated with 7 
x = 99 // now x is 99 it means it has been changed.

लेकिन अगर हम तब लेते हैं ...

let x = 7 // here also x is instantiated with 7 
x = 99 // this will a compile time error

चर को परिभाषित करने के लिए स्थिरांक और var को परिभाषित करने के लिए प्रयोग किया जाता है। आप var का उपयोग करके स्ट्रिंग को परिभाषित करते हैं तो विशेष स्ट्रिंग को एक चर (जिसे इस मामले में संशोधित किया जा सकता है) को निर्दिष्ट करके संशोधित (या उत्परिवर्तित) किया जा सकता है, और यदि आप स्ट्रिंग को परिभाषित करते हैं तो इसे स्थिर रखें (इस स्थिति में यह नहीं हो सकता है संशोधित):

var variableString = "Apple"
variableString += " and Banana"
// variableString is now "Apple and Banana"

let constantString = "Apple"
constantString += " and another Banana"
// this reports a compile-time error - a constant string cannot be modified

चलिए स्थिरांक के लिए प्रयोग किया जाता है जिसे संशोधित नहीं किया जा सकता है जबकि var एक सामान्य चर है

उदाहरण:

नाम = "बॉब" नाम की तरह कुछ = "जिम" एक त्रुटि फेंक देगा क्योंकि निरंतर संशोधित नहीं किया जा सकता है।


तेजी से हमारे पास दो प्रकार के चर होते हैं

  1. वर
  2. चलो

ये दोनों कार्य समान हैं, वस्तुओं (प्रतिलिपि मूल्य, संदर्भ मूल्य और आदि) शामिल हैं।

विभिन्न चर में मैं प्रोग्राम निष्पादित करते समय ऑब्जेक्ट को किसी अन्य में बदल सकता हूं

var x = 12
x = 13 // it is Ok

वैरिएबल में मैं ऑब्जेक्ट को किसी दूसरे पर परिवर्तित नहीं कर सकता, जबकि प्रोग्राम निष्पादित करता है, मुझे इसे पहले शुरू करना होगा। यह जावा, सी ++ जैसी दूसरी भाषाओं में स्थिर या अंतिम की तरह है।

let x = 12
x = 13 // it is not OK , it will generate error

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

var str      = "dog"  // str value is "dog"
str          = "cat"  // str value is now "cat"

let strAnimal = "dog" // strAnimal value is "dog"
strAnimal     = "cat" // Error !

विभिन्न कीवर्ड के साथ चलो कीवर्ड और चर के साथ स्थिरांक घोषित करें।

let maximumNumberOfLoginAttempts = 10 var currentLoginAttempt = 0   
let maximumNumberOfLoginAttempts = 10
var currentLoginAttempt = 0

कॉमा द्वारा अलग किए गए एकल लाइन पर एकाधिक स्थिरांक या एकाधिक चर घोषित करें:

var x = 0.0, y = 0.0, z = 0.0

मुद्रण स्थिरांक और चर

आप println फ़ंक्शन के साथ निरंतर या चर के वर्तमान मान को प्रिंट कर सकते हैं:

println(friendlyWelcome)

स्विफ्ट एक स्ट्रिंग इंटरपोलेशन का उपयोग करता है ताकि एक स्थिर स्ट्रिंग में प्लेसहोल्डर के रूप में निरंतर या चर का नाम शामिल हो सके

नाम कोष्ठक में नाम लपेटें और उद्घाटन कोष्ठक से पहले बैकस्लैश से बचें:

println("The current value of friendlyWelcome is \(friendlyWelcome)")

संदर्भ: http://iosswift.com.au/?p=17


स्विफ्ट में एक चर बनाने के लिए var एकमात्र तरीका है। var मतलब जावास्क्रिप्ट जैसे व्याख्या की गई भाषाओं के मामले में गतिशील चर नहीं है। उदाहरण के लिए,

var name = "Bob"

इस मामले में, चर name का प्रकार अनुमान लगाया गया है कि नाम String प्रकार का है, हम स्पष्ट रूप से परिभाषित प्रकार के द्वारा चर बना सकते हैं, उदाहरण के लिए

var age:Int = 20

अब यदि आप उम्र के लिए एक स्ट्रिंग असाइन करते हैं, तो संकलक त्रुटि देता है।

let स्थिरांक घोषित करने के लिए प्रयोग किया जाता है। उदाहरण के लिए

let city = "Kathmandu"

या हम भी कर सकते हैं,

let city:String = "Kathmandu"

यदि आप शहर के मूल्य को बदलने की कोशिश करते हैं, तो यह संकलन समय पर त्रुटि देता है।


हालांकि वर्तमान में मैं अभी भी मैन्युअल पढ़ रहा हूं, लेकिन मुझे लगता है कि यह सी / सी ++ const पॉइंटर के बहुत करीब है। दूसरे शब्दों में, char const* और char* बीच अंतर की तरह कुछ। कंपाइलर भी सामग्री को अद्यतन करने से इनकार करता है, न केवल संदर्भ पुन: असाइनमेंट (सूचक)।

उदाहरण के लिए, मान लें कि आपके पास यह संरचना है। ध्यान रखें कि यह एक संरचना है, कक्षा नहीं। AFAIK, कक्षाओं में अपरिवर्तनीय राज्य की अवधारणा नहीं है।

import Foundation


struct
AAA
{
    var inner_value1    =   111

    mutating func
    mutatingMethod1()
    {
        inner_value1    =   222
    }
}


let aaa1    =   AAA()
aaa1.mutatingMethod1()      // compile error
aaa1.inner_value1 = 444     // compile error

var aaa2    =   AAA()
aaa2.mutatingMethod1()      // OK
aaa2.inner_value1 = 444     // OK

चूंकि structs डिफ़ॉल्ट रूप से अपरिवर्तनीय हैं, इसलिए आपको mutating साथ एक म्यूटेटर विधि को चिह्नित करने की आवश्यकता है। और क्योंकि aaa1 नाम स्थिर है, आप इस पर किसी भी म्यूटेटर विधि को कॉल नहीं कर सकते हैं। यह वही है जो हमने सी / सी ++ पॉइंटर्स पर अपेक्षित था।

मेरा मानना ​​है कि यह एक तरह की कॉन्स-शुद्धता सामग्री का समर्थन करने के लिए एक तंत्र है।


स्विफ्ट प्रोग्रामिंग भाषा प्रलेखन के कॉन्स्टेंट और वेरिएबल अनुभाग घोषित करना निम्नलिखित निर्दिष्ट करता है:

आप विविध कीवर्ड के साथ चलो कीवर्ड और चर के साथ स्थिरांक घोषित करते हैं।

यह समझना सुनिश्चित करें कि यह संदर्भ प्रकारों के लिए कैसे काम करता है। वैल्यू प्रकारों के विपरीत, ऑब्जेक्ट की अंतर्निहित गुण स्थिर संदर्भ के रूप में घोषित संदर्भ प्रकार के उदाहरण के बावजूद बदल सकते हैं। कक्षाएं दस्तावेज के संदर्भ प्रकार अनुभाग देखें, और उदाहरण देखें कि वे फ्रेमरेट संपत्ति को बदलते हैं।


let एक "स्थिर" परिभाषित let । इसका मूल्य एक बार और केवल एक बार सेट किया जाता है, हालांकि जब आप इसे घोषित करते हैं तो जरूरी नहीं है। उदाहरण के लिए, आप कक्षा में किसी संपत्ति को परिभाषित करने के लिए उपयोग let हैं जिसे प्रारंभिकरण के दौरान सेट किया जाना चाहिए:

class Person {

    let firstName: String
    let lastName: String

    init(first: String, last: String) {
         firstName = first
         lastName = last
         super.init()
    }
}

इस सेटअप के साथ, कॉल करने के बाद firstName या अंतिम firstName को असाइन करना अमान्य है (उदाहरण के लिए) Person(first:"Malcolm", last:"Reynolds") एक Person उदाहरण बनाने के लिए।

आपको संकलन समय पर सभी चर ( let या var ) के लिए एक प्रकार को परिभाषित करना होगा , और कोई भी कोड जो चर सेट करने का प्रयास करता है केवल उस प्रकार (या उप प्रकार) का उपयोग कर सकता है। आप रन टाइम पर एक मान असाइन कर सकते हैं, लेकिन इसका प्रकार संकलन समय पर जाना जाना चाहिए।


let एक स्थिर मूल्य घोषित करने के लिए उपयोग किया जाता है जिसका अर्थ है कि आप इसे प्रारंभिक मान देने के बाद इसे नहीं बदलेंगे।
var का उपयोग वैरिएबल वैल्यू को डीकैले करने के लिए किया जाता है जिसका मतलब है कि आप अपनी इच्छानुसार वैल्यू बदल सकते हैं।


चलो एक निरंतर मूल्य है, इसलिए इसे कभी नहीं बदला जा सकता है।

let number = 5  
number = 6               //This will not compile.

Var एक चर है, और बदल सकता है (लेकिन इसके बाद इसे एक अलग डेटा प्रकार के रूप में परिभाषित नहीं किया जाता है।)

var number = 5
number = 6               //This will compile.

यदि आप वैरिएबल को एक अलग डेटा टाइप में बदलने का प्रयास करते हैं, तो यह काम नहीं करेगा

var number = 5
number = "Hello World"   //This will not compile.

बहुत आसान:

  • let स्थिर है।
  • var गतिशील है।

विवरण का बिट:

let एक स्थिर बनाता है। (एक NSString की तरह)। एक बार सेट करने के बाद आप अपना मूल्य बदल नहीं सकते हैं। आप अभी भी इसे अन्य चीजों में जोड़ सकते हैं और नए चर बना सकते हैं।

var एक चर बनाता है। (एनएसएमयूटेबलस्ट्रिंग की तरह) ताकि आप इसका मूल्य बदल सकें। लेकिन यह कई बार जवाब दिया गया है।





swift