Swift एक मां है? और उसके दो बेटे हैं? -
- वैल्यू टाइप ??♀️
- रेफरेंस टाइप ?♂️
लेकिन उनकी विशेषताएं क्या हैं??♂️
क्या वे एक दूसरे के समान या विपरीत व्यवहार करते हैं? ?♂️
Swift Apple द्वारा iOS, macOS, watchOS, tvOS, Linux, और z/OS के लिए विकसित एक मल्टी-पैराडाइम प्रोग्रामिंग भाषा है।?
अन्य ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग भाषाओं की तरह, Swift में क्लासेस बिल्डिंग ब्लॉक्स के रूप में हैं जो मेथड्स, प्रॉपर्टीज, इनिशियलाइज़र्स को परिभाषित कर सकते हैं, और प्रोटोकॉल्स के अनुरूप हो सकते हैं, इनहेरिटेंस और पॉलीमॉर्फिज्म का समर्थन करते हैं।?
लेकिन, रुको रुको रुको…???
Swift में स्ट्रक्ट्स भी हैं और वे मेथड्स, प्रॉपर्टीज, इनिशियलाइज़र्स को परिभाषित कर सकते हैं और इनहेरिटेंस के एकमात्र अपवाद के साथ प्रोटोकॉल्स के अनुरूप हो सकते हैं।?
क्या? अब मैं भ्रमित हूँ!!! ???
अब अपने भ्रम को बढ़ाते हैं: स्ट्रक्ट्स केवल Swift में वैल्यू टाइप्स नहीं हैं। टपल्स और एनम्स भी वैल्यू टाइप्स हैं। क्लासेस भी रेफरेंस टाइप के रूप में उपयोग किए जाने वाले एकमात्र नहीं हैं। फ़ंक्शन्स और क्लोजर्स भी रेफरेंस टाइप्स हैं। लेकिन राहत के प्रतीक के रूप में, हम कम से कम इन प्रकारों के उपयोग के प्राथमिक फोकस और विशेषज्ञता जानते हैं।?
तो इस बिंदु तक, हम केवल स्ट्रक्ट्स और क्लासेस के उपयोग के साथ घूम रहे एक बड़े भ्रम के साथ रह गए हैं।?
तो, चलिए घूम रहे भ्रम को दूर करते हैं।?♂️
स्टोरेज स्थान
तीन प्रकार के स्टोरेज उपलब्ध हैं:
- रजिस्टर ?
- स्टैक ☄️
- हीप ?
जिन ऑब्जेक्ट्स का जीवनकाल छोटा होता है वे रजिस्टर या स्टैक के अंदर संग्रहीत होते हैं और जिनका जीवनकाल लंबा होता है वे हीप के अंदर संग्रहीत होते हैं।?
एक वैल्यू टाइप स्टैक में आवंटित मेमोरी में अपनी सामग्री को संग्रहीत करता है, इसलिए हम कह सकते हैं कि Swift में वैल्यू टाइप्स स्टैक में आवंटित होते हैं। ?
लेकिन वैल्यू टाइप्स के बारे में एक आम गलत धारणा है, क्या आपने इसके बारे में सुना है??♂️
गलत धारणा यह है कि ज्यादातर लोग सोचते हैं कि वैल्यू टाइप्स हमेशा स्टैक में संग्रहीत होते हैं।
❌❌ एक मिनट रुकिए — यह हमेशा ऐसा नहीं होता। ❌❌
वैल्यू टाइप्स स्टैक के अंदर संग्रहीत हो सकते हैं जब वे या तो अस्थायी या स्थानीय चर होते हैं। लेकिन क्या होगा अगर एक वैल्यू टाइप एक रेफरेंस टाइप के अंदर समाहित है?
इस स्थिति में, इसे हीप मेमोरी के अंदर संग्रहीत किया जा सकता है। ?
वाह...यह कूल है!!!?
तो वैल्यू टाइप्स अपने जीवनकाल के आधार पर रजिस्टर, स्टैक या हीप के अंदर संग्रहीत हो सकते हैं, चाहे वे छोटे जीवन वाले हों या लंबे जीवन वाले। यदि यह एक स्थानीय चर है तो यह स्टैक के अंदर रह सकता है और यदि यह क्लास का हिस्सा है तो यह हीप मेमोरी के अंदर भी रह सकता है।✅
दूसरी ओर, रेफरेंस टाइप हीप मेमोरी में आवंटित मेमोरी में अपनी सामग्री को संग्रहीत करता है और चर केवल उस मेमोरी स्थान का एक रेफरेंस रखता है जहां वास्तविक डेटा संग्रहीत किया गया है। ??
रेफरेंस टाइप के लिए यह कैसे काम करता है??
तो रेफरेंस टाइप के लिए, यह काफी आम स्थिति है जब कई चर एक ही मेमोरी स्थान का रेफरेंस रख सकते हैं।⚔️
जब एक वैल्यू टाइप इंस्टेंस को एक चर को असाइन किया जाता है या फ़ंक्शन में पास किया जाता है, तो इंस्टेंस कॉपी हो जाता है और उस चर को असाइन कर दिया जाता है। लेकिन रेफरेंस टाइप के साथ, केवल रेफरेंस कॉपी हो जाता है और नया चर उसी मेमोरी स्थान का वही रेफरेंस रखता है। ?
म्यूटेबिलिटी के संदर्भ में अंतर
एक चर के लिए दो अवस्थाएं हो सकती हैं:
- ?♀ ️म्यूटेबल ?♀
- ?️♂️ इम्यूटेबल ?️♂️
यदि एक वैल्यू टाइप इंस्टेंस को एक इम्यूटेबल चर को असाइन किया जाता है, तो इंस्टेंस भी इम्यूटेबल हो जाता है। परिणामस्वरूप, हम उस इंस्टेंस में कोई बदलाव नहीं कर सकते।?♂️
यदि एक वैल्यू टाइप इंस्टेंस को एक म्यूटेबल चर को असाइन किया जाता है, तो केवल यह इंस्टेंस को म्यूटेबल बनाता है। ?♂️
लेकिन रेफरेंस टाइप्स के लिए चीजें पूरी तरह से अलग हैं। चर और वह इंस्टेंस जिसे इसे असाइन किया गया है, पूरी तरह से अलग हैं। यदि हम एक क्लास का रेफरेंस रखने वाले एक इम्यूटेबल चर की घोषणा करते हैं, तो इसका मतलब है कि यह जो रेफरेंस रखता है वह कभी नहीं बदलेगा। हम रेफरेंस को बदल नहीं सकते और यह हमेशा उसी रेफरेंस की ओर इशारा करेगा। ?
स्ट्रक्चरल प्रकार
स्ट्रक्चरल प्रकारों के मानों की तुलना उनके एट्रिब्यूट्स या एलिमेंट्स के संदर्भ में समानता के लिए की जाती है। हम कह सकते हैं कि एक वैल्यू टाइप दूसरे के बराबर है यदि और केवल यदि सभी संबंधित एट्रिब्यूट्स समान हैं। ???
उम्म...बहुत सारे कठिन शब्द...आपका क्या मतलब है???
मान लें, हमारे पास एक Person वैल्यू टाइप है जिसमें firstName और lastName. जैसे एट्रिब्यूट्स हैं।
struct Person { var firstName: String var lastName: String } var person1 = Person(firstName: "foo", lastName: "bar") var person2 = Person(firstName: "foo", lastName: "bar")
यहां दोनों person1 & person2 इंस्टेंस firstName के लिए समान मान ("foo") और lastName ("bar") रख रहे हैं। तो हमारी समझ के अनुसार, हम कह सकते हैं कि दोनों इंस्टेंस एक दूसरे के बराबर हैं क्योंकि उनके एट्रिब्यूट्स (firstName & lastName) समान मान रखते हैं।
लेकिन यह केवल इस तक सीमित नहीं है: भविष्य में, firstName & lastName के लिए समान मान रखने वाले कोई भी दो व्यक्ति इंस्टेंस एक दूसरे के बराबर होंगे।
तो इस बिंदु तक हमारी समझ के अनुसार, हम कह सकते हैं कि:
वैल्यू टाइप्स की कोई पहचान नहीं होती, इसलिए उनका कोई रेफरेंस नहीं हो सकता। वैल्यू टाइप्स फेसलेस हैं।?
क्या? आप ऐसा कैसे कह सकते हैं????
var myAge: Int = 21 var friendAge: Int = 21
दोनों myAge & friendAge मान 21 के साथ इंटीजर टाइप चर हैं।
क्या हम एक को दूसरे से अलग कर सकते हैं? ?
नहीं, क्योंकि वे समान मान रख रहे हैं।?
मान 21 वाला एक इंटीजर चर मान 21 वाले दूसरे इंटीजर चर से अलग नहीं हो सकता। बस इतना सरल।???
पहचान न होने से वैल्यू टाइप्स को एक और फायदा मिलता है: यदि आप व्यावहारिक रूप से सोचते हैं, तो आप कल्पना कर सकते हैं कि यदि आपके पास पहचान नहीं है तो समान विशेषताओं वाला कोई भी आपको बदल या प्रतिस्थापित कर सकता है। ???
यही हम मनुष्यों के लिए भी सोच सकते हैं। अगर मेरी कोई पहचान नहीं है तो समान विशेषताओं वाला कोई भी मुझे बदल सकता है???. अच्छा है कि हमारी पहचान है अन्यथा यह हमारे अस्तित्व के लिए बहुत बड़ा जोखिम होता।?
लेकिन वैल्यू टाइप्स के लिए, उनकी कोई पहचान नहीं है और यह उनके लिए एक फायदा है। ?
वैल्यू टाइप्स का उपयोग करने के क्या लाभ हैं?
? कोई रेस कंडीशन और डेडलॉक्स नहीं: ?
मल्टी-थ्रेडेड वातावरण में वैल्यू टाइप्स के लिए, एक थ्रेड के लिए दूसरे थ्रेड द्वारा उपयोग किए जाने के दौरान इंस्टेंस की स्थिति को बदलना असंभव है। इसलिए हम कह सकते हैं कि कोई रेस कंडीशन या डेडलॉक्स नहीं होंगे।
⚔️ कोई रिटेन साइकल नहीं: ⚔️
जब दो रेफरेंस टाइप इंस्टेंस होते हैं जो एक दूसरे के लिए मजबूत रेफरेंस रखते हैं और एक दूसरे को मेमोरी से डीअलोकेट होने से रोकते हैं, तो इसे रिटेन साइकल कहा जाता है। चूंकि वैल्यू टाइप्स रेफरेंस के रूप में काम नहीं करते, इसलिए हम कह सकते हैं कि वैल्यू टाइप्स के लिए कोई रिटेन साइकल नहीं होगा।
???? ऑटोमैटिक रेफरेंस काउंटिंग: ????
रेफरेंस टाइप के लिए, Swift सभी लाइव या सक्रिय ऑब्जेक्ट्स को ट्रैक करने के लिए ऑटोमैटिक रेफरेंस काउंटिंग का उपयोग करता है और इंस्टेंस को केवल तभी डीअलोकेट करता है जब उसके लिए कोई मजबूत रेफरेंस नहीं रह जाते। यदि हम थोड़ा सोचें, तो हम कह सकते हैं कि यह एक भारी ऑपरेशन है क्योंकि Swift रनटाइम को हमेशा ऑब्जेक्ट्स को ट्रैक करने की आवश्यकता होती है। लेकिन चूंकि वैल्यू टाइप्स स्टैक में आवंटित होते हैं, इसलिए उन्हें ARC की आवश्यकता नहीं होती। इसलिए यह सस्ता और तेज़ है??.
लेकिन रुको...यह Array, Dictionary और String के लिए मेमोरी कैसे प्रबंधित करता है??
चूंकि हम कंपाइल टाइम पर एक सरणी, एक डिक्शनरी, और एक स्ट्रिंग का वास्तविक आकार नहीं जान सकते, इसलिए उनके लिए कंपाइल टाइम पर आवंटित होने की कोई गुंजाइश नहीं है। यद्यपि वे आंतरिक रूप से वैल्यू टाइप्स हैं, वे स्टैक में आवंटित नहीं हो सकते। उन्हें हीप मेमोरी में आवंटित करने की आवश्यकता है, और इसे प्रबंधित करने के लिए, Swift कॉपी ऑन राइट के साथ आता है।?
लेकिन यह क्या है??
जब हम कहते हैं कि एक इंस्टेंस दूसरे इंस्टेंस की कॉपी है, तो इसका वास्तव में मतलब है कि वे समान हैं, कि उनमें समान मान हैं। लेकिन Swift में, इन उपरोक्त प्रकारों (Array, Dictionary, String, आदि) के लिए, हीप पर वास्तविक कॉपी तभी बनाई गई है जब एक इंस्टेंस म्यूटेट होता है। इसे वैल्यू टाइप्स के लिए एक प्रदर्शन अनुकूलन तकनीक कहा जाता है।???
निष्कर्ष
ऐसा कोई कठिन नियम नहीं है जो परिभाषित करता हो कि कब वैल्यू टाइप का उपयोग करना है और कब रेफरेंस टाइप का उपयोग करना है। वैल्यू टाइप्स के रेफरेंस टाइप्स पर कुछ अनूठे फायदे हैं और इसके विपरीत। वे दोनों अपने तरीके से अद्वितीय हैं। यह वास्तव में आपकी आवश्यकताओं और आप क्या हासिल करने की कोशिश कर रहे हैं उस पर निर्भर करता है। आपको अपने कोड के अर्थशास्त्र को जानना चाहिए क्योंकि आप अपने कोड को सबसे अच्छे से जानते हैं, इसलिए यह आप पर निर्भर है कि आप क्या चुनते हैं। आपके पास पूरी स्वतंत्रता है।
तो वैल्यू टाइप बनाम रेफरेंस टाइप पर लड़ने के बजाय, उन्हें बुद्धिमानी से उपयोग करें।
??? चीयर्स!!! पढ़ने के लिए धन्यवाद!! ???
✅✅✅आप मुझे Twitter पर पा सकते हैं।✅✅✅