பண்புகள் மற்றும் குணாதிசய எல்லைகள்

பண்புகள் ஒரு குறிப்பிட்ட வகையின் நடத்தையை வரையறுக்கிறது மற்றும் பிற வகைகளுடன் பகிர்ந்து கொள்ளலாம். பிற நிரலாக்க மொழிகளில் உள்ள இடைமுகங்களைப் போலவே, ஒரு குறிப்பிட்ட பொதுவான செயல்பாடு அல்லது இடைமுகத்தைக் குறிக்கும் முறைகளின் தொகுப்பை வரையறுக்க பண்புகளைப் பயன்படுத்தலாம்.

பண்பு வரம்புகள் ஒரு பொதுவான வகை ஒரு குறிப்பிட்ட பண்பைச் செயல்படுத்த வேண்டும் என்பதைக் குறிப்பிட அனுமதிக்கிறது, தொகுக்கும் நேரத்தில் தேவையான முறைகள் கிடைக்கின்றன என்பதை உறுதிப்படுத்துகிறது.

ஒரு பண்பை வரையறுத்தல் மற்றும் செயல்படுத்துதல்

ஒரு பண்பை வரையறுக்க, நாங்கள் 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: பண்புகளைப் பயன்படுத்தி பகுதி கணக்கீடு