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

Question

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

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

Comments

चलो स्थिरांक के लिए है, चर चर के लिए है।

— कोलिन हेंडरसन

@Edward आप संकलन समय पर किसी भी प्रकार की जाँच से क्या मतलब है? जहां तक ​​मैं बता सकता हूं, यह सांख्यिकीय रूप से टाइप किया गया है, लेकिन प्रकार का अनुमान लगाया जाता है यदि कंपाइलर इसे खुद से समझ सकता है। लेकिन तब मैं केवल पेज 25 पर हूं ... ;-)

— जोकिम इस्कसन 20

यह विषय पर है, लेकिन एक खराब तरीके से किया गया प्रश्न है। कम से कम 2 प्रश्न हैं (i) let और var के बीच अंतर ; (ii) सुरक्षित बनाम टाइप प्रकार। इसके अलावा, जब पोस्टर ने उत्पादन चरण का उल्लेख किया , तो वह वास्तव में रन टाइम पर था।

— केविन ले - खलनाले

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

— लॉरेंट

स्विफ्ट प्रोग्रामिंग लैंग्वेज में डिफरेंट लेट और वर

— संभवत:

Answer 1

letकीवर्ड एक निरंतर परिभाषित करता है:

let theAnswer = 42

theAnswerबाद में बदला नहीं जा सकता। यही कारण है कि कुछ weakका उपयोग कर नहीं लिखा जा सकता है let। उन्हें रनटाइम के दौरान बदलने की आवश्यकता है और आपको varइसके बजाय उपयोग करना होगा ।

varएक साधारण चर को परिभाषित करता है।

रोचक क्या है:

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

एक और अजीब विशेषता:

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

let 🐶🐮 = "dogcow"

इसके अंश: Apple Inc. "स्विफ्ट प्रोग्रामिंग लैंग्वेज।" iBooks। https://itunes.apple.com/WebObjects/MZStore.woa/wa/viewBook?id=881256329

संपादित करें

क्योंकि टिप्पणियों में उत्तर के लिए अन्य तथ्यों को जोड़ने के लिए कहा जाता है, इसे सामुदायिक विकि उत्तर में परिवर्तित किया जाता है । बेहिचक उत्तर को बेहतर बनाने के लिए संपादित करें।

Comments

C और C ++ यूनिकोड के माध्यम से यूनिकोड पहचानकर्ताओं को भी अनुमति देता है। यदि कंपाइलर किसी भी यूनिकोड स्रोत एन्कोडिंग का समर्थन करता है तो आप सीधे यूनिकोड वर्णों का उपयोग कर सकते हैं। उदाहरण के लिए auto 🐶🐮 = "dogcow";C ++ में क्लैंग के लिए काम करता है।

— bames53

@ bames53 ठीक है, मुझे यकीन नहीं है कि मैं इस तरह एक कार्यक्रम को डिबग करना चाहता हूं: if 😍 === 💝 { 💔 = ♠︎ }:);)

— jm666

क्या यह REPL पर लागू होता है? क्योंकि आप REPL में स्थिरांक को पुन: सौंप सकते हैं।

— अहमद अल हफौद

सबसे पहले, जैसा कि ऊपर उल्लेख किया गया है, यह आरईपीएल में पूरी तरह से अलग है। दूसरा, अगर यह एक स्थिर है तो यह एक से अधिक नहीं है। यह संकलक में ठीक काम करता है: foo = [1,2,3]; foo [2] = 5; Println ("(foo)") // [१, २, ५]

— केविन फ्रॉस्ट

यह उत्तर, हालांकि सबसे अधिक अपवित्र है, किसी भी प्रकार का उल्लेख नहीं करता है कि मान प्रकार के बजाय ऑब्जेक्ट्स का संदर्भ देते समय कैसे / var व्यवहार करते हैं। कुंजी यह है कि दोनों मामलों में आप अभी भी ऑब्जेक्ट के गुणों को बदल सकते हैं, लेकिन किसी अन्य ऑब्जेक्ट को संदर्भित करने के लिए पॉइंटर को संशोधित नहीं कर सकते। पूर्णांकों और तारों से जुड़े बुनियादी उदाहरणों से यह तुरंत स्पष्ट नहीं है।

— साल्टनट्स

Answer 2

द स्विफ्ट प्रोग्रामिंग लैंग्वेज बुक के अनुसार

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

दोनों संदर्भ हैं varऔर इसलिए एक संदर्भ है । मौलिक प्रकारों का उपयोग करना वास्तव में नहीं दिखाता है कि कैसे अलग है । वर्ग उदाहरणों (संदर्भ प्रकार) के साथ इसका उपयोग करते समय अंतर आता है:letletletconst

class CTest
{
    var str : String = ""
}

let letTest = CTest()
letTest.str = "test" // OK

letTest.str = "another test" // Still OK

//letTest = CTest() // Error

var varTest1 = CTest()
var varTest2 = CTest()
var varTest3 = CTest()

varTest1.str = "var 1"
varTest2.str = "var 2"
varTest3 = varTest1
varTest1.str = "var 3"

varTest3.str // "var 3"

Comments

यह शब्दावली पूरी तरह से गलत है ... सभी संदर्भ वास्तव में संदर्भ हैं। "कॉन्स्टेंट रेफरी" की कोई अवधारणा नहीं है। एक बार बाध्य होने के बाद, एक संदर्भ हमेशा एक ही मेमोरी पते से जुड़ा होता है और इसे बदला नहीं जा सकता है या "अनटाइटेड" नहीं किया जा सकता है। मेरा मानना ​​है कि आप का मतलब है कि var एक "पॉइंटर" है और लेट "a const पॉइंटर" है

— AyBayBay

@AyBayBay जबकि आप जो लिख रहे हैं वह C C ++ में सही है। मुझे लगता है कि उपरोक्त स्निपेट साबित होता है, कि स्विफ्ट में ऐसा नहीं है। संकेत सूचक अंकगणितीय और प्रत्यक्ष मेमोरी एक्सेस की अनुमति देंगे, जो फिर से यहां नहीं है। - संपादित करें: मुझे कोई सबूत नहीं मिला है कि सभी संदर्भ वास्तव में कॉन्स्ट संदर्भ हैं जो हर प्रोग्रामिंग भाषा के लिए सही है।

— क्रिजाक

विकिपीडिया के संकेत के अनुसार BTW संदर्भ हैं

— Krzak

मैं मानता हूं कि आपकी शब्दावली गलत है। varऔर letइस बात से कोई लेना-देना नहीं है कि पहचानकर्ता बाध्य है, संदर्भ के लिए है या नहीं। यदि प्रकार एक structप्रकार है, तो यह वैचारिक रूप से एक मूल्य है। यदि प्रकार है, classतो यह वैचारिक रूप से एक संदर्भ है और यदि letउपयोग किया जाता है तो संदर्भ एक स्थिर है। यदि CTestएक संरचना थी, तो आपका कोई भी letTestकाम नहीं करेगा।

— जेरेमीप

यदि प्रकार structयह एक मान प्रकार है, तो इसके बारे में कुछ भी वैचारिक नहीं है। के साथ ही class- संदर्भ प्रकार। एक मूल्य प्रकार modyfing जब आप इस प्रकार का एक नया उदाहरण बनाते हैं। developer.apple.com/swift/blog/?id=10 तो जाहिर है आप letमूल्य के प्रकार के लिए फ़ील्ड / गुणों को संशोधित नहीं कर सकते ।

— क्रजक

Answer 3

letका उपयोग स्थिरांक varको परिभाषित करने और चर को परिभाषित करने के लिए किया जाता है ।

Answer 4

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

2 डेटा प्रकार: मान प्रकार और संदर्भ प्रकार।

मूल्य प्रकारों के संदर्भ में:

'लेट' एक स्थिर मान (अचूक) को परिभाषित करता है। 'var' एक परिवर्तनशील मूल्य (परस्पर) को परिभाषित करता है।

let aInt = 1   //< aInt is not changeable

var aInt = 1   //< aInt can be changed

संदर्भ प्रकारों के संदर्भ में:

किसी डेटा का लेबल मान नहीं बल्कि मान का संदर्भ है।

अगर aPerson = व्यक्ति (नाम: फू, पहला: बार)

aPerson में इस व्यक्ति का डेटा नहीं है लेकिन इस व्यक्ति के डेटा का संदर्भ है।

let aPerson = Person(name:Foo, first:Bar)
               //< data of aPerson are changeable, not the reference

var aPerson = Person(name:Foo, first:Bar)
               //< both reference and data are changeable.

eg:
var aPersonA = Person(name:A, first: a)
var aPersonB = Person(name:B, first: b)

aPersonA = aPersonB

aPersonA now refers to Person(name:B, first: b)

Comments

लेकिन अगर aPersonआप बस गए हैं तो आप इसके गुणों को संशोधित कर सकते हैं? इसलिए letनहीं है Personअपरिवर्तनीय।

— 4

Unmutability? यह असंभव है! निश्चित रूप से विरोधी। मुझे लगता है कि आप जिस शब्द की तलाश कर रहे हैं, वह "अपरिवर्तनीयता" हो सकता है :-)

— paxdiablo

Answer 5

The

स्विफ्ट प्रोग्रामिंग लैंग्वेज डॉक्यूमेंटेशन के कॉन्स्टेंट और वेरिएबल्स सेक्शन की घोषणा निम्नलिखित करती है:

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

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

Answer 6

बहुत आसान:

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

विवरण के बिट:

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

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

Answer 7

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

class Person {

    let firstName: String
    let lastName: String

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

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

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

Answer 8

let- constant
var-variable

[लगातार बनाम चर]
[संरचना बनाम कक्षा]

आधिकारिक doc docs.swift.org का कहना है

एक का मूल्य constantएक जबकि, एक बार यह सेट नहीं बदला जा सकता variableभविष्य में एक अलग मान पर सेट किया जा सकता है।

यह शब्दावली वास्तव में एक पुनर्मूल्यांकन तंत्र का वर्णन करती है

उत्परिवर्तन - परिवर्तनशील - निर्माण के बाद वस्तु की स्थिति को बदला जा सकता है

मूल्य और संदर्भ प्रकार ^{[के बारे में]}

मान (संरचना, एनम)

स्विफ्ट की structपरिवर्तनशीलता की स्थिति बदल सकती है:

let+ struct= immutable= मूल्य की लगातार
यह कर सकते हैं नहीं किया जा पुन: असाइन या बदल

var+ struct= mutable
इसे पुन: सौंपा या बदला जा सकता है

संदर्भ प्रकार (कक्षा)

स्विफ्ट की classesहैं mutableएक-मठ

let+ class= पते की निरंतरता
यह आश्वस्त नहीं किया जा सकता है और इसे बदला जा सकता है

var+ class
इसे पुन: सौंपा या बदला जा सकता है

//STRUCT
  //let + struct
let letStructA = StructA()

    //change FAIL
letStructA.a = 5 //Compile ERROR: Cannot assign to property: 'structALet' is a 'let' constant

    //reassign FAIL
letStructA = StructA() // Compile ERROR: Cannot assign to value: 'structALet' is a 'let' constant

  //var + struct
var varStructA = StructA()

    //change OK
varStructA.a = 5

    //reassign OK
varStructA = StructA()

//CLASS
  //let + class
let letClassA = ClassA()

    //change OK
letClassA.a = 5

    //reassign FAIL
letClassA = ClassA() // Compile ERROR: Cannot assign to value: 'classALet' is a 'let' constant

  //var + class
var varClassA = ClassA()

    //change OK
varClassA.a = 5

    //reassign OK
varClassA = ClassA()

mutating - उत्परिवर्तन संरचना के कार्य

आप एक संरचना के तरीके को चिह्नित कर सकते हैंmutating

1. इंगित करता है कि यह फ़ंक्शन आंतरिक गुण मान बदलता है।
2. केवल var+ पर उपयोग किया जा सकता हैstruct

public struct StructA {
    public var a = 0

    public init() {}

    //func foo() { //Compile ERROR: Cannot assign to property: 'self' is immutable
    mutating func foo() {
        a = 5
    }
}

inout किसी फ़ंक्शन के अंदर संरचना को संशोधित करना

आप एक फ़ंक्शन के पैरामीटर (जो कि संरचनात्मक है) को चिह्नित कर सकते हैं inout

structएक मूल्य प्रकार के बाद से , यह मूल्य द्वारा पारित किया जाता है परिणामस्वरूप फ़ंक्शन एक प्रतिलिपि प्राप्त करेगा। यदि आप एक पैरामीटर के structरूप में चिह्नित करते हैं inoutतो इसका मतलब है कि यह पैरामीटर बन गया है varऔर आप एक स्थिति को बदलने में सक्षम हैं structऔर ये परिवर्तन फ़ंक्शन स्कोप के बाहर दिखाई देंगे

//func foo(myStruct: StructA) { //Compile ERROR: line - myStruct.a = 10: Cannot assign to property: 's' is a 'let' constant
func foo(myStruct: inout StructA) {
    myStruct.a = 10
}

//using
//foo(myStruct: &letStructA) // Compile EROOR: Cannot pass immutable value as inout argument: 'letStructA' is a 'let' constant
foo(myStruct: &varStructA)

letजब भी आप कर सकते हैं का उपयोग करें । varजब आप का उपयोग करें ।

Answer 9

एक और अंतर, जिसे मैंने कॉन्स्टेंट्स के लिए अन्य भाषाओं में सामना किया है: बाद में इसके लिए स्थिरांक (लेट) को इनिशियलाइज़ नहीं कर सकता , जैसा कि आप कॉन्स्टेंट को घोषित करने के बारे में करते हैं।

उदाहरण के लिए :

let constantValue : Int // Compile error - let declarations require an initialiser expression

परिवर्तनशील

var variableValue : Int // No issues 

Answer 10

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

Answer 11

जाने स्थिरांक और परिभाषित करने के लिए प्रयोग किया जाता है वर चर निर्धारित करने। आप स्ट्रिंग को 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

Answer 12

कीवर्ड को एक स्थिर परिभाषित करते हैं

let myNum = 7

इसलिए myNum को बाद में नहीं बदला जा सकता है;

लेकिन 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

Answer 13

ल्यूक-ओलिवर की तरह, नलदत्ता और कुछ अन्य लोगों ने यहां कहा है, letअपरिवर्तनीय डेटा को varपरिभाषित करता है जबकि उत्परिवर्तनीय डेटा को परिभाषित करता है। कोई भी funcजिसे चर के रूप में चिह्नित किया mutatingजा सकता है उसे केवल तभी बुलाया जा सकता है जब वह varचर है (संकलक त्रुटि फेंक देगा)। यह भी लागू होता है funcकि एक में ले लोinout चर ।

हालाँकि, letऔर varयह भी मतलब है कि चर को फिर से असाइन नहीं किया जा सकता है। इसके दो अर्थ हैं, दोनों समान उद्देश्यों के साथ

Answer 14

वैरिएबल इनिशियलाइज़ होने के बाद बदल सकता है। लेकिन जाने मूल्य परिवर्तन हो जाता है, जब यह intilize एक बार है।

वर के मामले में

  function variable() {
     var number = 5, number = 6;
     console.log(number); // return console value is 6
   }
   variable();

के मामले में

   function abc() {
      let number = 5, number = 6;
      console.log(number); // TypeError: redeclaration of let number
   }
   abc();

Comments

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

— टाइगर

स्विफ्ट में कोई कंसोल नहीं है। ओपी के टैग की जाँच करें

— Dan Beaulieu

Answer 15

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

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 

Answer 16

आज्ञा देना एक अपरिवर्तनीय चर है, जिसका अर्थ है कि इसे बदला नहीं जा सकता है, अन्य भाषाएं इसे एक स्थिर कहती हैं। C ++ में आप इसे const के रूप में परिभाषित कर सकते हैं।

वार एक परिवर्तनशील चर है, जिसका अर्थ है कि इसे बदला जा सकता है। C ++ (2011 संस्करण अपडेट) में, यह ऑटो का उपयोग करने के समान है, हालांकि स्विफ्ट उपयोग में अधिक लचीलेपन की अनुमति देता है। यह शुरुआती लोगों के लिए अधिक प्रसिद्ध चर प्रकार है।

Answer 17

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

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.

Comments

Let किया जाना चाहिए चलो ।

— टाइगर

Answer 18

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

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

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

Comments

Let and Var छोटे अक्षर में काम करना (let and var) नहीं है।

— अभिषेक

Answer 19

एक मान को 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.

Answer 20

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

Excerpt From: Apple Inc. “The Swift Programming Language.” iBooks. https://itun.es/us/jEUH0.l

Answer 21

वर वैरिएबल है जिसे आप जितनी बार और जितनी बार चाहें बदल सकते हैं

उदाहरण के लिए

var changeit:Int=1
changeit=2
 //changeit has changed to 2 

---

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

उदाहरण के लिए

let changeit:Int=1
changeit=2
 //Error becuase constant cannot be changed

Answer 22

भले ही आपको पहले से दो और var के बीच कई अंतर मिले हों, लेकिन एक मुख्य अंतर यह है:

let is compiled fast in comparison to var.

Answer 23

हर किसी ने इसका बहुत उत्तर दिया है लेकिन यहाँ एक तरीका है जिसे आप याद रख सकते हैं कि क्या है

हमेशा "चलो" के बारे में ऐसा ही सोचें, जैसा कि इस काम को एक बार और हमेशा "var" वेरिएबल के लिए करते हैं, इसलिए हमेशा बदल सकते हैं इसलिए उन्हें वेरिएबल कहा जा रहा है

Answer 24

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

var name = "Bob"

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

var age:Int = 20

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

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

let city = "Kathmandu"

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

let city:String = "Kathmandu"

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

Answer 25

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

उदाहरण:

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

Answer 26

सरल ज्ञान

लेट = (बदला नहीं जा सकता)

var = (किसी भी समय अद्यतन)

Comments

यह मौजूदा जवाबों में से कई का सिर्फ एक दोहराव प्रतीत होता है।

— पैंग

Answer 27

स्रोत: https://thenucleargeeks.com/2019/04/10/swift-let-vs-var/

जब आप वेरिएबल के साथ एक वैरिएबल घोषित करते हैं, तो इसका मतलब है कि इसे अपडेट किया जा सकता है, यह वेरिएबल है, यह वैल्यू मॉडिफाई किया जा सकता है।

जब आप एक चर को घोषणा के साथ घोषित करते हैं, तो इसका मतलब है कि इसे अपडेट नहीं किया जा सकता है, यह गैर चर है, यह मूल्य संशोधित नहीं किया जा सकता है।

var a = 1 
print (a) // output 1
a = 2
print (a) // output 2

let b = 4
print (b) // output 4
b = 5 // error "Cannot assign to value: 'b' is a 'let' constant"

आइए हम उपरोक्त उदाहरण को समझें: हमने एक नया वेरिएबल "a" "var कीवर्ड" के साथ बनाया है और "1" वैल्यू असाइन किया है। जब मैं "a" प्रिंट करता हूं, तो मुझे आउटपुट 1 मिलता है। फिर मैं 2 को "var" देता हूं, यानी मैं वेरिएबल का मूल्य "a" कर रहा हूं। मैं इसे संकलक त्रुटि प्राप्त किए बिना कर सकता हूं क्योंकि मैंने इसे var घोषित किया था।

दूसरे परिदृश्य में मैंने "Let कीवर्ड" के साथ एक नया वैरिएबल "b" बनाया और "4" का मान दिया। जब मैं "b" प्रिंट करता हूं तो मुझे आउटपुट के रूप में 4 मिला है। फिर मैं 5 को "लेट बी" असाइन करने का प्रयास करता हूं, यानी मैं "लेट" वेरिएबल को संशोधित करने की कोशिश कर रहा हूं और मुझे कंपाइल टाइम एरर मिलता है "असाइन नहीं किया जा सकता है: 'b' एक 'लेट' स्थिर है।

Answer 28

हालांकि वर्तमान में मैं अभी भी मैनुअल पढ़ रहा हूं, लेकिन मुझे लगता है कि यह C / C ++ 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

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

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

Answer 29

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

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

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

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

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

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

println(friendlyWelcome)

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

कोष्ठक में नाम लपेटें और शुरुआती कोष्ठक से पहले एक बैकस्लैश के साथ बच जाएं:

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

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

Answer 30

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

Comments

यह वास्तव में गलत है। letइसका मतलब यह नहीं है कि ऑब्जेक्ट अपरिवर्तनीय है, इसका मतलब है कि सूचक अपरिवर्तनीय है। ओबज-सी में समान कार्यक्षमता प्राप्त करने के लिए आपको उपयोग करने की आवश्यकता है NSObject *const myObject = someobject;- ऐसी वस्तु के गुणों को संशोधित किया जा सकता है, लेकिन सूचक myObjectको किसी अन्य वस्तु को इंगित करने के लिए संशोधित नहीं किया जा सकता है।

— साल्टनट्स

पूरी तरह से गलत जवाब। क्या आपने एक लेट एरे के साथ कोशिश की है : NSMutableArray = NSMutableArray () ?? आप इसमें वस्तुओं को / से जोड़ / हटा सकते हैं। आइए बनाते हैं const pointerकि भविष्य में परिवर्तन नहीं हो सकता है, लेकिन इसका मूल्य क्या हो सकता है। आप इसे फिर से संगठित नहीं कर सकते, लेकिन जैसा चाहें वैसा उपयोग कर सकते हैं।

— टाइगर