लक्षण और विशेषता सीमाएँ

विशेषताएँ उस व्यवहार को परिभाषित करते हैं जो एक विशेष प्रकार का होता है और जिसे अन्य प्रकार के साथ साझा किया जा सकता है। हम तरीकों के एक सेट को परिभाषित करने के लिए लक्षणों का उपयोग कर सकते हैं जो अन्य प्रोग्रामिंग भाषाओं में इंटरफेस के समान एक निश्चित सामान्य कार्यक्षमता या इंटरफ़ेस का प्रतिनिधित्व करते हैं।

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

किसी विशेषता को परिभाषित करना और कार्यान्वित करना

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

pub trait Summary {
    fn summarize(&self) -> String;
}

किसी विशेषता को किसी ठोस प्रकार पर लागू करने के लिए, हम सिंटैक्स impl TraitName for TypeName का उपयोग करते हैं:

pub struct NewsArticle {
    pub headline: String,
    pub content: String,
}

impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}", self.headline)
    }
}

गुण सीमा

सामान्य फ़ंक्शन लिखते समय, हम यह सुनिश्चित करने के लिए प्रकार के मापदंडों को सीमित कर सकते हैं कि वे एक विशिष्ट विशेषता को लागू करते हैं। मानक सिंटैक्स <T: Trait> है:

pub fn notify<T: Summary>(item: &T) {
    println!("Notification: {}", item.summarize());
}

वैकल्पिक रूप से, अधिक जटिल हस्ताक्षरों के लिए, हम where क्लॉज़ का उपयोग कर सकते हैं:

pub fn notify_advanced<T>(item: &T)
where
    T: Summary
{
    println!("Notification: {}", item.summarize());
}

खुद कोशिश करना

अभ्यास 1: सारांश विशेषता

अभ्यास 2: प्रिंट_सारांश के साथ विशेषता सीमाएँ

अभ्यास 3: लक्षणों का उपयोग करके क्षेत्र की गणना