முக்கிய உள்ளடக்கத்திற்குச் செல்லவும்
தொகுதி 7 · பாடம் 1 இன் 2பாடத்திட்டத்தில் 13/14~12 min
தொகுதி பாடங்கள் (1/2)

தொகுப்புகள் மற்றும் HashMap

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

ரஸ்டில் பொதுவாகப் பயன்படுத்தப்படும் இரண்டு சேகரிப்புகள் வெக்டர்கள் (Vec<T>) மற்றும் முக்கிய மதிப்பு வரைபடங்கள் (HashMap<K, V>).


திசையன்கள் (Vec<T>)

ஒரே மாதிரியான ஒன்றுக்கு மேற்பட்ட மதிப்புகளை ஒரே தரவு கட்டமைப்பில் சேமிக்க திசையன்கள் உங்களை அனுமதிக்கின்றன, இது அனைத்து மதிப்புகளையும் நினைவகத்தில் அடுத்ததாக வைக்கிறது:

Rust
fn main() {
    // Creating an empty mutable vector
    let mut v: Vec<i32> = Vec::new();

    // Or using the vec! macro
    let mut v2 = vec![1, 2, 3];

    // Appending elements
    v.push(5);
    v.push(6);

    // Accessing elements by index
    let third = v2[2];
    println!("The third element is: {}", third);
}

ஹாஷ்மேப் (HashMap<K, V>)

HashMap<K, V> சேகரிப்பு V வகை மதிப்புகளுக்கு K வகையின் விசைகளின் மேப்பிங்கைச் சேமிக்கிறது. இது ஹாஷிங் செயல்பாட்டின் மூலம் செயல்படுகிறது, இது இந்த விசைகள் மற்றும் மதிப்புகள் எவ்வாறு நினைவகத்தில் வைக்கப்படுகின்றன என்பதை தீர்மானிக்கிறது. நீங்கள் தரவை எண் குறியீட்டின் மூலம் பார்க்காமல், ஒரு விசை (பெயர் அல்லது ஐடி போன்றவை) மூலம் பார்க்க விரும்பும்போது இது மிகவும் பயனுள்ளதாக இருக்கும்.

Rust
use std::collections::HashMap;

fn main() {
    let mut scores = HashMap::new();

    // Inserting key-value pair
    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Yellow"), 50);

    // Reading a value (returns an Option<&V>)
    let team_name = String::from("Blue");
    let score = scores.get(&team_name);

    match score {
        Some(val) => println!("Score: {}", val),
        None => println!("No score found."),
    }
}

நீங்களே முயற்சி செய்து பாருங்கள்

பயிற்சி 1: Vec இல் அடிப்படை செயல்பாடுகள்

உடற்பயிற்சி#rust.m7.l1.e1
முயற்சிகள்: 0ஏற்றுகிறது…

Vec ::new() ஐப் பயன்படுத்தி v என்ற பெயரிடப்பட்ட மாறக்கூடிய முழு எண் வெக்டரை அறிவிக்கவும். புஷ் முறையைப் பயன்படுத்தி 10, 20 மற்றும் 30 உறுப்புகளை வரிசையில் சேர்க்கவும். இறுதியாக, println ஐப் பயன்படுத்தி திசையன் (குறியீட்டு 0) முதல் உறுப்பை அச்சிடுக!.

எடிட்டரை ஏற்றுகிறது…
குறிப்பைக் காட்டு

வெக்டரை துவக்குவதற்கு `let mut v = Vec::new();` ஐப் பயன்படுத்தவும், `v.push(value)` உடன் உறுப்புகளைச் செருகவும் மற்றும் `v[0]` உடன் அணுகவும்.

3 முயற்சிகளுக்குப் பிறகு தீர்வு கிடைக்கும்

பயிற்சி 2: HashMap உடன் பயனர் மதிப்பெண்கள்

உடற்பயிற்சி#rust.m7.l1.e2
முயற்சிகள்: 0ஏற்றுகிறது…

இறக்குமதி std::collections::HashMap. முக்கிய செயல்பாட்டில், ஸ்ட்ரிங் விசைகள் மற்றும் i32 மதிப்புகளைச் சேமிக்க, மாற்றக்கூடிய HashMap மதிப்பெண்களை அறிவிக்கவும். 'ஆலிஸ்' பயனருக்கு 50 மதிப்பெண்களைச் செருகவும். பெறு முறையைப் பயன்படுத்தி மதிப்பெண்ணைப் பாதுகாப்பாகப் பிரித்தெடுத்து, அதை அச்சிட அவிழ்த்துவிடவும்().

எடிட்டரை ஏற்றுகிறது…
குறிப்பைக் காட்டு

`பயன்படுத்த std::collections::HashMap;`என்பதை மறந்துவிடாதீர்கள்.`scores.insert(String::from("Alic"), 50);` உடன் செருகவும், மேலும்`.get("Alice").unwrap()` உடன் மதிப்பைப் பெறவும்.

3 முயற்சிகளுக்குப் பிறகு தீர்வு கிடைக்கும்

பயிற்சி 3: வெக்டரில் மதிப்புகளை இரட்டிப்பாக்குதல்

உடற்பயிற்சி#rust.m7.l1.e3
முயற்சிகள்: 0ஏற்றுகிறது…

முழு எண்களின் &[i32] ஒரு குறிப்பை ஏற்று, 2 ஆல் பெருக்கப்படும் அதே கூறுகளைக் கொண்ட புதிய Vec<i32>ஐ வழங்கும் double_values ​​என்ற செயல்பாட்டை வரையறுக்கவும்.

எடிட்டரை ஏற்றுகிறது…
குறிப்பைக் காட்டு

செயல்பாடு ஸ்லைஸின் உறுப்புகளின் மீது மீண்டும் மீண்டும் செலுத்தப்பட வேண்டும் மற்றும் அவற்றை 2 ஆல் பெருக்கப்படும் புதிய வெக்டரில் செருக வேண்டும்.

3 முயற்சிகளுக்குப் பிறகு தீர்வு கிடைக்கும்