परिवर्तनशील संदर्भ या परिवर्तनशील चर? रस्ट के म्यूट-म्यूट-म्यूट को डिकोड करना

पहचान

भले ही रस्ट अपनी रस्ट पुस्तक प्रदान करता है, फिर भी मुझे mut कीवर्ड को समझने में कठिनाई हुई। मैंने खुद से पूछा, "क्या मैं अकेला हूं जिसे यह समस्या है?" एक त्वरित Google खोज ने पुष्टि की कि मैं अकेला नहीं था।

परिणामस्वरूप, मैंने mut कीवर्ड का विस्तृत विवरण प्रदान करने के लिए यह लेख लिखने का निर्णय लिया। यह लेख उन लोगों के लिए है जो उच्च-स्तरीय भाषाओं जैसे कि पायथन या जावास्क्रिप्ट से आते हैं।

चर

रस्ट में एक अपरिवर्तनीय वैरिएबल बनाने के लिए, बस let x = 1337 लिखें। यह सीधा है. यदि आप एक ऐसा वैरिएबल बनाना चाहते हैं जिसे बाद में बदला जा सके, तो बस let के बाद mut कीवर्ड जोड़ें। रस्ट में एक सहायक परंपरा है जो इरादों की स्पष्टता को प्रोत्साहित करती है।

mut कीवर्ड जोड़ने से दूसरों को सूचित होता है कि यह वेरिएबल कोड में कहीं और संशोधित किया जाएगा। ठीक है।

आइए इसकी कल्पना करें। यहां दो चर हैं, let mut x = 1337 और let y = 42 ।

सन्दर्भ

फिलहाल, सब कुछ सीधा है. हालाँकि, mut संदर्भों का उपयोग करते समय चीजें थोड़ी घुंघराले होने लगती हैं। आइए कुछ बनाएं.

 let mut x = 1337; let y = 42; let x_ref = &mut x; let y_ref = &y;

मैंने दो संदर्भ बनाए (या जंग के संदर्भ में "उधार लिया")। उनमें से एक परिवर्तनशील संदर्भ है, और दूसरा केवल पढ़ने योग्य संदर्भ है। आइए उसके लिए फिर से एक योजना बनाएं।

दी गई योजना में, मेरे पास 4 चर हैं, जिनमें से 2 संदर्भ हैं। दोनों संदर्भ चर अपरिवर्तनीय हैं और उनमें let के बाद mut कीवर्ड नहीं है, जिसका अर्थ है कि वे जो इंगित करते हैं उसे मैं बदल नहीं सकता। हालाँकि, मैं अभी भी उनके द्वारा संदर्भित मूल्य को बदल सकता हूँ।

 *x_ref = 777;

यदि आप इसे लिखते हैं, तो रस्ट कंपाइलर शिकायत नहीं करेगा, और x का मान (रेफरी स्वयं नहीं) 777 में बदल जाएगा। हालाँकि, योजना पर एक लाल वर्ग है जो दर्शाता है कि x_ref में परिवर्तनशीलता विकल्प का अभाव है। तो, मैं इसके द्वारा संदर्भित मूल्य को क्यों बदल सकता हूँ?

चलिए let x_ref = &mut x की योजना पर वापस आते हैं।

पहले सफ़ेद ब्लॉक में नाम है: x_ref . दूसरा मुझे उस वेरिएबल में संग्रहीत प्रकार के बारे में सूचित करता है। इसके पूर्ण रूप में, बिना किसी अंतर्निहित प्रकार की टिप्पणियों के, मैं इस प्रकार लिख सकता हूं:

 let x_ref: &mut i32 = &mut x;

मैं इसकी व्याख्या इस प्रकार कर सकता हूं: आइए x_ref नामक एक अपरिवर्तनीय चर बनाएं जो i32 के लिए एक परिवर्तनशील संदर्भ रखेगा और इसे x चर में i32 मान के परिवर्तनीय संदर्भ के साथ तुरंत आरंभ करेगा।

इसका मतलब यह है कि मैं उस मान को संशोधित कर सकता हूं जो यह इंगित करता है, लेकिन मैं संदर्भ के मान (या पते) को नहीं बदल सकता। दूसरे शब्दों में, मैं ऐसा कुछ नहीं लिख सकता:

 let x_ref: &mut i32 = &mut x; let mut z = 0; x_ref = &mut z; // Not allowed!

योजनाओं के संदर्भ में, मैं ऊपर दिए गए कोड ब्लॉक में तीर जिस दिशा की ओर इशारा कर रहा है उसे बदलना चाहता हूं। हालाँकि, भले ही z वेरिएबल परिवर्तनशील हो, मैं तीर नहीं बदल सकता क्योंकि समस्या x_ref की अपरिवर्तनीयता में ही निहित है।

तीर की दिशा बदलने के लिए, मुझे x_ref वेरिएबल में संग्रहीत पते को संशोधित करना होगा। हालाँकि, मैं ऐसा नहीं कर सकता क्योंकि चर अपरिवर्तनीय है।

चलो यह करते हैं!

 let mut x: i32 = 1337; let mut x_ref: &mut i32 = &mut x; // I've added mut before x_ref let mut z = 0; x_ref = &mut z; // Allowed!

यहाँ x_ref के आसपास mut के बहुत सारे उदाहरण हैं, है ना? आइए उनका वर्णन करें.

1. let mut x_ref : मैं x_ref नामक एक परिवर्तनीय चर बना रहा हूं, जिसका अर्थ है कि मैं बाद में इसका मान बदल सकता हूं।

   
   

2. &mut i32 : मैं बता रहा हूं कि वेरिएबल में i32 प्रकार के कुछ मानों के लिए परिवर्तनीय संदर्भ शामिल होंगे।

   
   

3. &mut x : मैं वेरिएबल x उधार ले रहा हूं (संदर्भ प्राप्त कर रहा हूं)।

   
   

फिर, मैंने z नामक एक वेरिएबल बनाया और इसे 0 का मान दिया। बाद में, जब मैंने x_ref = &mut z लिखा, तो मैंने संकेत दिया कि मैं x_ref को एक परिवर्तनशील चर समझता हूं जो केवल i32 मानों के संदर्भ रख सकता है।

चूँकि z का प्रकार i32 है, मैं इसका पता x_ref वेरिएबल को निर्दिष्ट करने में सक्षम हूँ। z का पता प्राप्त करने के लिए, मैंने &mut z सिंटैक्स का उपयोग किया।

यह योजना।

मानसिक युक्ति

कथन में = पर एक नज़र डालें, यह थोड़ा स्पष्ट लग सकता है, लेकिन...

 let mut x_ref = &mut x;

... मैं इसे एक विभाजक के रूप में देखता हूं (खासकर यदि आप इसे 90 डिग्री तक घुमाते हैं) जो कथन को दो उप-कथनों में विभाजित करता है: बाएँ और दाएँ। बाईं ओर वेरिएबल के बारे में जानकारी प्रदान करता है, जबकि दाईं ओर हमें मूल्य के बारे में बताता है।

जब मैं मान बदलने के लिए * डेरेफ़रेंस ऑपरेटर का उपयोग करता हूं...

 *x_ref = 100;

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

अपरिवर्तनीय सन्दर्भ

मैं पहले अक्सर mut उपयोग करता था। यदि मैं उनमें से कुछ को छोड़ दूं तो क्या होगा?

 let i = 1; let j = 2; let mut k = &i;

क्या मैं यहाँ i का मान बदल सकता हूँ? विभाजक तकनीक का उपयोग करके, इसका उत्तर देना काफी सरल है। मैं k का मान बदल सकता हूँ (मुझे बाईं ओर mut दिखाई देता है), लेकिन मान (दाईं ओर) i का एक अपरिवर्तनीय संदर्भ है (यहाँ कोई mut नहीं है)।

इसलिए…

 let i = 1; let j = 2; let mut k = &i; k = &j; // This is legal. *k = 3; // This is not.

यह योजना।

निष्कर्ष

इस लेख में, हमने mut कीवर्ड और संदर्भों की बारीकियों का विश्लेषण किया है। याद रखें, परिवर्तनशील संदर्भ और संदर्भ रखने वाले परिवर्तनशील चर के बीच अंतर होता है। हमारी चाल?

रस्ट में असाइनमेंट को बेहतर ढंग से समझने के लिए मानसिक विभाजक के रूप में = चिह्न का उपयोग करना। यह सरल दृश्य कई भ्रमों को दूर कर सकता है।

हैप्पी कोडिंग!