Learn Rust Coding · บทเรียน

เวกเตอร์ของ struct

เก็บข้อมูลซับซ้อนใน Vec

บทเรียน 4 จาก 413 ขั้นตอน

เวกเตอร์ของ struct เป็นบทเรียน Learn Rust Coding ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Learn Rust Coding และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 4 บทเรียน

เหตุผลที่ใช้เวกเตอร์ของโครงสร้างข้อมูล

เวกเตอร์สามารถเก็บข้อมูลชนิดเดียวกันชนิดใดก็ได้ รวมถึงโครงสร้างข้อมูลที่คุณสร้างเอง Vec<Person> ใช้เก็บ people หลายรายการตามลำดับ จึงเหมาะกับรายการข้อมูลระเบียน เช่น ผู้ใช้ รายการสินค้า หรือคะแนน

วิธีนี้ผสานรูปแบบข้อมูลแบบกำหนดเองเข้ากับรายการที่ขยายขนาดได้

การกำหนดโครงสร้างข้อมูล

ขั้นแรก ให้กำหนดโครงสร้างข้อมูลที่ต้องการจัดเก็บ Person นี้มีชื่อและอายุ

บรรทัด #[derive(Debug)] ช่วยให้เราแสดงผลบุคคลด้วย {:?} ซึ่งมีประโยชน์สำหรับเวกเตอร์ทั้งชุด

#[derive(Debug)]
struct Person {
    name: String,
    age: u32,
}

การสร้างเวกเตอร์

สร้างอินสแตนซ์ของโครงสร้างข้อมูล แล้วรวบรวมไว้ในแมโคร vec! ชนิดของเวกเตอร์จะกลายเป็น Vec<Person> โดยอัตโนมัติ

ใช้ {:?} เพื่อแสดงผลระเบียนทั้งหมดในครั้งเดียว

#[derive(Debug)]
struct Person { name: String, age: u32 }

fn main() {
    let people = vec![
        Person { name: String::from("Ann"), age: 30 },
        Person { name: String::from("Bo"), age: 25 },
    ];
    println!("{:?}", people);
}

การเพิ่มโครงสร้างข้อมูลด้วย push

คุณสามารถเริ่มจากเวกเตอร์ว่าง แล้วใช้ push เพิ่มโครงสร้างข้อมูลทีละรายการได้ เวกเตอร์ต้องเป็น mut จึงจะขยายขนาดได้

รูปแบบนี้เหมาะเมื่อระเบียนทยอยเข้ามาตามเวลา เช่น จากข้อมูลนำเข้าของผู้ใช้

#[derive(Debug)]
struct Item { name: String }

fn main() {
    let mut cart = Vec::new();
    cart.push(Item { name: String::from("Pen") });
    cart.push(Item { name: String::from("Mug") });
    println!("{:?}", cart);
}

การวนซ้ำผ่านระเบียน

วนซ้ำผ่าน &people เพื่ออ่านโครงสร้างข้อมูลแต่ละรายการโดยไม่เข้าครอบครองความเป็นเจ้าของ ภายในลูป คุณเข้าถึงฟิลด์ด้วยสัญลักษณ์จุด เช่น p.name

วิธีนี้จะแสดงบรรทัดที่อ่านง่ายสำหรับแต่ละระเบียน

#[derive(Debug)]
struct Person { name: String, age: u32 }

fn main() {
    let people = vec![
        Person { name: String::from("Ann"), age: 30 },
        Person { name: String::from("Bo"), age: 25 },
    ];
    for p in &people {
        println!("{} is {}", p.name, p.age);
    }
}

การอ่านฟิลด์หนึ่งรายการ

ใช้ดัชนีของเวกเตอร์เพื่อเข้าถึงโครงสร้างข้อมูลหนึ่งรายการ แล้วใช้สัญลักษณ์จุดเพื่อเข้าถึงฟิลด์ ดังนั้น people[0].name จะให้ชื่อของบุคคลคนแรก

โปรดจำไว้ว่าดัชนีเริ่มที่ 0 และการเข้าถึงนอกช่วงจะทำให้โปรแกรมตื่นตระหนก

#[derive(Debug)]
struct Person { name: String, age: u32 }

fn main() {
    let people = vec![
        Person { name: String::from("Ann"), age: 30 },
    ];
    println!("name: {}", people[0].name);
}

การเปลี่ยนฟิลด์

หากต้องการแก้ไขระเบียน เวกเตอร์ต้องเป็น mut จากนั้นใช้ดัชนีเข้าถึงโครงสร้างข้อมูลแล้วกำหนดค่าให้ฟิลด์ เช่น people[0].age = 31

วิธีนี้จะอัปเดตข้อมูลที่จัดเก็บไว้โดยตรง

struct Person { name: String, age: u32 }

fn main() {
    let mut people = vec![
        Person { name: String::from("Ann"), age: 30 },
    ];
    people[0].age = 31;
    println!("{}", people[0].age);
}

การหาผลรวมของฟิลด์

ตัววนซ้ำสามารถดึงฟิลด์หนึ่งรายการจากทุกระเบียนได้ ในที่นี้ iter().map(|p| p.age).sum() จะบวกอายุทั้งหมดเข้าด้วยกัน

ขั้นตอน map เปลี่ยนแต่ละบุคคลให้เหลือเพียงอายุก่อนนำไปหาผลรวม

struct Person { name: String, age: u32 }

fn main() {
    let people = vec![
        Person { name: String::from("Ann"), age: 30 },
        Person { name: String::from("Bo"), age: 20 },
    ];
    let total: u32 = people.iter().map(|p| p.age).sum();
    println!("total age = {}", total);
}

การกรองระเบียน

ใช้ iter().filter(...) เพื่อเก็บระเบียนที่ตรงตามกฎ คลอเชอร์จะคืนค่าบูลีนสำหรับโครงสร้างข้อมูลแต่ละรายการ

ในที่นี้เรานับจำนวน people ที่มีอายุอย่างน้อย 30 ปี

struct Person { name: String, age: u32 }

fn main() {
    let people = vec![
        Person { name: String::from("Ann"), age: 30 },
        Person { name: String::from("Bo"), age: 20 },
    ];
    let adults = people.iter().filter(|p| p.age >= 30).count();
    println!("adults: {}", adults);
}

การเรียงลำดับตามฟิลด์

เรียงระเบียนตามฟิลด์ด้วย sort_by_key โดยส่งคลอเชอร์ที่คืนค่าที่ใช้จัดลำดับ เช่น อายุ

เวกเตอร์ต้องเป็น mut เพราะการเรียงลำดับจะจัดสมาชิกใหม่

#[derive(Debug)]
struct Person { name: String, age: u32 }

fn main() {
    let mut people = vec![
        Person { name: String::from("Ann"), age: 30 },
        Person { name: String::from("Bo"), age: 20 },
    ];
    people.sort_by_key(|p| p.age);
    println!("{:?}", people);
}

การนับจำนวนระเบียน

จำนวนโครงสร้างข้อมูลที่จัดเก็บไว้คือ len() เช่นเดียวกับเวกเตอร์ทุกชนิด ค่านี้บอกว่าขณะนี้คุณมีระเบียนอยู่กี่รายการ

ใช้คู่กับ is_empty() เพื่อป้องกันก่อนอ่านระเบียนแรก

struct Item { name: String }

fn main() {
    let cart = vec![
        Item { name: String::from("Pen") },
        Item { name: String::from("Mug") },
    ];
    println!("items: {}", cart.len());
}

ตรวจสอบความเข้าใจ

ทดสอบความเข้าใจของคุณเกี่ยวกับเวกเตอร์ของโครงสร้างข้อมูล

ตอบคำถามในบทเรียนแบบโต้ตอบ

สรุปทบทวน

คุณจัดเก็บโครงสร้างข้อมูลใน Vec สร้างเวกเตอร์ด้วย vec! และ push และอ่านหรือแก้ไขฟิลด์ด้วยดัชนีและลูป

คุณยังหาผลรวม กรอง เรียงลำดับตามฟิลด์ และนับระเบียนได้ ตอนนี้คุณสามารถจัดการรายการข้อมูลที่มีโครงสร้างด้วยเวกเตอร์ได้แล้ว

เริ่มต้นได้ฟรี

เรียนรู้ Rust ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส: 39
บทเรียน: 144

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

คำถามที่พบบ่อย

บทเรียน “เวกเตอร์ของ struct” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “เวกเตอร์ของ struct” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Learn Rust Coding ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “เวกเตอร์ของ struct”

เก็บข้อมูลซับซ้อนใน Vec คุณปฏิบัติ Learn Rust Coding ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Learn Rust Coding หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Learn Rust Coding บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “เวกเตอร์ของ struct” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Learn Rust Coding นี้ได้ไหม

ได้ บทเรียน Learn Rust Coding ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Learn Rust Coding