जंग के सामान्य प्रकार को समझना

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

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

जंग में सामान्य प्रकार का उपयोग करना

रस्ट का सामान्य प्रकार इंटरऑपरेट कर सकता है अन्य जंग डेटा प्रकार. आप सामान्य प्रकार को कोण कोष्ठक (<>) के साथ परिभाषित करेंगे, जिसके बाद दो या अधिक पैरामीटर होंगे।

यहाँ एक सामान्य है संरचना परिभाषा जो दो सामान्य प्रकार के पैरामीटर लेता है:

structबिंदु {
// टी और यू सामान्य प्रकार के पैरामीटर हैं जो एक्स और वाई फ़ील्ड होंगे 
// इन्स्टेन्शियशन पर मान लें
 एक्स: टी,
 वाई: यू,
}

में बिंदु संरचना, टी, और यू सामान्य प्रकार के पैरामीटर हैं।

आप सामान्य प्रकार के मापदंडों को तात्कालिकता पर किसी भी डेटा प्रकार से बदल सकते हैं:

fnमुख्य() {
होने देना my_point = पॉइंट { x: डोरी::से("नमस्ते"), वाई: डोरी::से("दुनिया") };
प्रिंटल!(
"my_point का x मान {} है और y मान {} है।",
 my_point.x,
 my_point.y
 );
}

मेरी बात का चर का एक उदाहरण है बिंदु संरचना स्ट्रिंग प्रकारों के साथ आरंभ की गई। रस्ट कंपाइलर के ठोस प्रकारों का अनुमान लगाता है टी और यू तात्कालिकता पर मूल्यों के आधार पर।

सामान्य प्रकार के लिए विशेषता सीमा

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

विशेषता सीमाएँ निर्दिष्ट करती हैं कि एक सामान्य प्रकार को एक या अधिक लक्षणों को लागू करना चाहिए।

यहां एक सामान्य फ़ंक्शन का एक उदाहरण दिया गया है जो एक विशेषता सीमा के साथ दो से अधिक मान लौटाता है जो यह सुनिश्चित करता है कि प्रकार की तुलना विशेषता को लागू करती है:

// अधिकतम एक विशेषता है जो अधिकतम दो का मूल्यांकन करने के लिए एक विधि को परिभाषित करती है
// प्रकार
प्रवृत्तिअधिकतम {
fnअधिकतम(खुद, अन्य: खुद) -> खुद;
}
// लागू करने वाले सभी प्रकारों के लिए `अधिकतम` विशेषता लागू करता है
// `पार्शियलऑर्ड` विशेषता।
प्रत्ययआंशिकऑर्ड> अधिकतम के लिए टी {
fnअधिकतम(खुद, अन्य: खुद) -> खुद {
// रिटर्न `स्वयं` यदि यह `अन्य` से अधिक है; अन्यथा लौट जाओ
// `अन्य।`
अगरखुद > अन्य {
खुद
 } अन्य {
 अन्य
 }
 }
}
fnमुख्य() {
होने देना एक = 5;
होने देना बी = 10;
होने देना सबसे बड़ा = अधिकतम:: अधिकतम (ए, बी);
प्रिंटल!("सबसे बड़ा मूल्य है {}", विशालतम);
}

अधिकतम विशेषता है अधिकतम विधि जो एक ही प्रकार के दो मानों में से बड़ा लौटाती है। कोई भी प्रकार जो लागू करता है आंशिकऑर्ड गुण लागू करता है अधिकतम प्रवृत्ति।

अधिकतम विधि के दो मान लेता है खुद प्रकार - लागू करने वाले प्रकार का जिक्र अधिकतम विशेषता - और मूल्यों की तुलना करता है।

मुख्य फ़ंक्शन का उपयोग करके दो चर की तुलना करता है अधिकतम विधि और सबसे बड़ा प्रिंट करता है।

सामान्य प्रकार के लिए प्रतिबन्ध

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

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

// ToString एक स्ट्रिंग रूपांतरण विधि के साथ एक विशेषता है
प्रवृत्तिस्ट्रिंग {
fnस्ट्रिंग(&खुद) -> डोरी;
}
// to_string एक सामान्य कार्य है जो किसी भी प्रकार का मान लेता है
// ToString विशेषता लागू करता है
fnस्ट्रिंगस्ट्रिंग>(मूल्य: टी) -> डोरी {
 value.to_string ()
}

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

लक्षणों के साथ कार्य करने के लिए सामान्य प्रकार उपयोगी होते हैं

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

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