रस्ट के लक्षण और जीवनकाल को समझना

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

दायरे के भीतर और बाहर चर के स्वामित्व को ट्रैक करने के लिए जंग एक अन्य तंत्र-जीवनकाल-का उपयोग करता है। यह वेरिएबल डीललोकेशन के दौरान लटकने वाले पॉइंटर्स को रोकता है।

साथ में, लक्षण और जीवनकाल प्रकार की सुरक्षा, स्मृति सुरक्षा और कोड विश्वसनीयता सुनिश्चित करने में सहायता करते हैं।

जंग में लक्षण को समझना

लक्षण विधियों का संग्रह है जो अन्य प्रकार लागू कर सकते हैं। गुण से मिलते जुलते हैं जावा जैसी भाषाओं में इंटरफेस, गो, और टाइपस्क्रिप्ट लेकिन अधिक लचीला।

आप उपयोग करेंगे प्रवृत्ति रस्ट में लक्षणों को परिभाषित करने के लिए कीवर्ड, उसके बाद विधि हस्ताक्षरों की घोषणा।

प्रवृत्तिमायट्रेट {
fnmy_method(&खुद);
}

कोड नामित विशेषता को परिभाषित करता है मायट्रेट के साथ my_method तरीका। &खुद पैरामीटर इंगित करता है कि विधि कार्यान्वयन प्रकार की वस्तु को इसके पहले पैरामीटर के रूप में संदर्भित करती है।

एक विशेषता को परिभाषित करने के बाद, आप इसे अपने कस्टम प्रकारों के लिए कार्यान्वित कर सकते हैं।

यहां बताया गया है कि आप अपने स्ट्रक्चर टाइप के लिए किसी विशेषता को कैसे लागू कर सकते हैं।

structव्यक्ति {
 नाम: डोरी,
 आयु: यू32,
}
प्रत्यय जानकारी के लिए व्यक्ति {
fnसारांश(&खुद) {
प्रिंटल!("मेरा नाम {} है और मेरी उम्र {} साल है।", खुद।नाम, खुद।आयु);
 }
}

व्यक्ति संरचना लागू करता है जानकारी, और आप कॉल कर सकते हैं सारांश के उदाहरणों पर विधि व्यक्ति संरचना।

fnमुख्य(){
होने देना जॉन = व्यक्ति {नाम: डोरी::से("जॉन"), आयु: 30 };
 जॉन सारांश (); // आउटपुट: मेरा नाम जॉन है, और मेरी उम्र 30 साल है।
}

जॉन चर का एक उदाहरण है व्यक्ति संरचना।

मुख्य समारोह कॉल सारांश जो कंसोल को एक संदेश प्रिंट करता है:

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

एनुमMyEnum {
 वैरिएंटए,
 वैरिएंटबी,
}
प्रत्यय जानकारी के लिए मायएनम {
fnसारांश(&खुद) {
मिलानखुद {
 MyEnum:: VariantA => {
// VariantA के लिए कार्यान्वयन
 }
 MyEnum:: VariantB => {
// VariantB के लिए कार्यान्वयन
 }
 }
 }
}

फंक्शन पैरामीटर्स और रिटर्न वैल्यू के लिए ट्रेट्स का उपयोग करना

आप गुणों को फ़ंक्शन पैरामीटर और वापसी मान के रूप में उपयोग कर सकते हैं। कई प्रकार के जेनेरिक कोड लिखने के लिए फ़ंक्शन पैरामीटर के रूप में लक्षणों का उपयोग करना आसान है।

यहां एक ऐसा फ़ंक्शन है जो लागू होने वाले किसी भी प्रकार का पैरामीटर लेता है जानकारी.

fnकुछ करो(मूल्य: टी) {
 मूल्य सारांश ();
}

सिंटैक्स यह निर्दिष्ट करता है टी अमल करना चाहिए जानकारी. आप कॉल कर सकते हैं सारांश लागू होने वाले किसी भी मूल्य के साथ कार्य करें जानकारी.

लाइफटाइम्स इन रस्ट

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

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

जंग में, आप एपोस्ट्रोफ एनोटेशन का उपयोग करके जीवनकाल निर्दिष्ट कर सकते हैं:

फंक<'ए>

एक संदर्भ बनाने पर, संदर्भ को जीवन भर के लिए असाइन किया जाता है जो यह बताता है कि यह कितने समय के लिए वैध है। यदि आपके पास कोई ऐसा फ़ंक्शन है जो किसी मान का संदर्भ लेता है, तो यह सुनिश्चित करने के लिए जीवनकाल फ़ंक्शन कॉल से अधिक होना चाहिए कि फ़ंक्शन वापस आने पर मान मान्य है।

यहां किसी फ़ंक्शन में आजीवन विशिष्टता का उदाहरण दिया गया है।

fnकुछ करो<'ए>(एक्स: &'एi32) -> &'एi32 {
 एक्स
}
fnमुख्य() {
होने देना एक्स = 42;
होने देना परिणाम = do_something(&x);
प्रिंटल!("परिणाम है: {}", परिणाम);
}

में कुछ करो कार्य, द 'ए आजीवन पैरामीटर इंगित करता है कि संदर्भ एक्स जब तक फ़ंक्शन कॉल मान्य है। जब तक फ़ंक्शन कॉल किया जाता है तब तक लौटाया गया संदर्भ भी मान्य होता है।

मुख्य फ़ंक्शन एक संदर्भ पास करके परिणाम प्रिंट करता है एक्स में चर मुख्य कंसोल के लिए कार्य करें।

आजीवन सिंटैक्स वर्बोज़ हो सकता है, लेकिन यह सुरक्षा और स्मृति प्रबंधन के लिए आवश्यक है। तीन-आजीवन elision नियम दिशानिर्देश प्रदान करते हैं जो जंग को कुछ स्थितियों में संदर्भों के जीवनकाल का अनुमान लगाने की अनुमति देते हैं।

इनपुट लाइफटाइम नियम

इनपुट लाइफटाइम नियम निर्दिष्ट करता है कि यदि कोई फ़ंक्शन या विधि इनपुट पैरामीटर के रूप में एक या अधिक संदर्भ लेती है, तो रस्ट मानता है कि सभी संदर्भों का जीवनकाल समान है।

सीधे शब्दों में कहें, आउटपुट संदर्भों का जीवनकाल इनपुट संदर्भों के समान ही होगा।

fnसबसे लंबे समय तक<'ए>(एक्स: &'एएसटीआर, वाई: और'एएसटीआर) -> &'एएसटीआर {
अगर x.लेन ()> y.लेन () {x} अन्य {य}
}

में सबसे लंबे समय तक फ़ंक्शन, रस्ट का अनुमान है कि आउटपुट संदर्भ का जीवनकाल इनपुट संदर्भ के समान है क्योंकि उन दोनों का जीवनकाल पैरामीटर समान है 'ए.

इनपुट लाइफटाइम नियम सामान्य कार्यों को लिखना आसान बनाता है जो इनपुट के रूप में कई संदर्भ लेते हैं।

आउटपुट लाइफटाइम नियम

आउटपुट लाइफटाइम नियम निर्दिष्ट करता है कि यदि कोई फ़ंक्शन या विधि एक संदर्भ देता है, तो जंग यह मान लेगी कि आउटपुट संदर्भ का जीवनकाल किसी भी इनपुट संदर्भ के जीवनकाल से अलग है।

fnपहला शब्द<'ए>(ओं: &'एएसटीआर) -> &'एएसटीआर {
 s.split_whitespace().next().unwrap()
}

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

लाइफटाइम रूल का एलीशन

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

fnसबसे लंबे समय तक<'ए>(एक्स: &'एएसटीआर, वाई: औरएसटीआर) -> &'एएसटीआर {
अगर x.लेन ()> y.लेन () {x} अन्य {य}
}

इस फ़ंक्शन में, रस्ट का अनुमान है कि आउटपुट संदर्भ का जीवनकाल इनपुट संदर्भ के जीवनकाल के समान है क्योंकि इनपुट संदर्भ वाई कोई आजीवन पैरामीटर नहीं है। जंग के लिए आजीवन पैरामीटर समाप्त हो जाता है वाई और मानता है कि इसका जीवनकाल उतना ही है जितना एक्स.

यह नियम उन कार्यों को लिखना आसान बनाता है जो एक इनपुट संदर्भ लेते हैं और एक आउटपुट संदर्भ वापस करते हैं।

गुण और जीवनकाल

आप सामान्य कार्यों को बनाने के लिए लक्षण और जीवन काल को जोड़ सकते हैं जो एक विशेषता को लागू करने वाले प्रकारों के लिए काम करते हैं और एक वैध जीवनकाल है।

यहाँ एक विशेषता और एक फ़ंक्शन है जो उस मान को संदर्भित करता है जो विशेषता को लागू करता है।

प्रवृत्तिस्ट्रिंग {
fnस्ट्रिंग(&खुद) -> डोरी;
}
fnस्ट्रिंग<'ए, टी: स्ट्रिंग>(टी: &'ए टी) -> डोरी {
 टी.to_string()
}

यहाँ, आजीवन पैरामीटर 'ए संदर्भ सुनिश्चित करता है टी यह संदर्भित वस्तु के जीवनकाल के लिए मान्य है। आप उपयोग कर सकते हैं स्ट्रिंग लागू करने वाले प्रकारों के साथ कार्य करें स्ट्रिंग एक वैध जीवनकाल वाला गुण।

लक्षण जंग में ओओपी अवधारणाओं को लागू करने के लिए आधार बनाते हैं

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

इन OOP अवधारणाओं को लक्षणों के साथ लागू करने से आपके रस्ट प्रोग्राम स्केलेबल, मजबूत, रखरखाव योग्य और कुशल बन जाते हैं।