การออกแบบโครงสร้างข้อมูลด้วย Structs | Rust The Series EP.10

ยินดีต้อนรับเข้าสู่ตอนสุดท้ายของ Rust The Series (Basic Edition) ครับ! หลังจากที่เราฝ่าฟันเรียนรู้เรื่องกฎเหล็กการจัดการ Memory และการยืมข้อมูล (Borrowing) ของ Rust ไปแล้ว หลายคนอาจจะเริ่มมีคำถามในใจว่า:

"ถ้าผมต้องการสร้างตัวแปรเดียวที่เก็บข้อมูลหลายอย่างไว้ด้วยกัน เช่น ข้อมูลสมาชิกหนึ่งคน ที่มีทั้ง ชื่อ (String), อายุ (i32) และ สถานะสมาชิก (bool) ผมจะมัดรวมมันไว้ได้ยังไง?"

ในภาษาอื่นเราอาจจะนึกถึง Class หรือ Object แต่ในภาษา Rust เรามีอาวุธที่เรียกว่า Struct (Structure) ซึ่งเป็นเครื่องมือสำหรับสร้าง Data Type ในแบบฉบับของคุณเองครับ!

1. Struct คืออะไร?

ถ้าจะสรุปให้เข้าใจง่ายที่สุด Struct คือการนำข้อมูลหลายๆ ประเภทมามัดรวมกันเป็นก้อนเดียว โดยเราจะเรียกข้อมูลแต่ละตัวที่อยู่ในนั้นว่า Fields ครับ

ความเจ๋งของ Struct คือการที่เราสามารถตั้งชื่อให้กับข้อมูลแต่ละส่วนได้ (ต่างจาก Tuple ที่เราต้องจำตามลำดับ Index) ทำให้โค้ดของเราอ่านง่ายขึ้นมาก และมันเปรียบเสมือนแบบแปลน (Blueprint) ที่บอกว่าวัตถุชิ้นหนึ่งต้องประกอบด้วยข้อมูลอะไรบ้างนั่นเอง

Rust

// การประกาศ Struct (การสร้างแบบแปลน)
struct User {
    username: String,    // ชื่อผู้ใช้งาน
    email: String,       // อีเมล
    sign_in_count: u64,  // จำนวนครั้งที่เข้าสู่ระบบ
    active: bool,        // สถานะการใช้งาน (เปิด/ปิด)
}

2. การสร้าง Instance (นำแบบแปลนมาใช้จริง)

เมื่อเรามีแบบแปลน (Struct) แล้ว ขั้นตอนต่อไปคือการนำมาสร้างข้อมูลจริงที่เราเรียกว่า Instance ครับ

การสร้าง Instance ก็เหมือนกับการกรอกข้อมูลลงในแบบฟอร์มที่เราเตรียมไว้ โดยมีจุดที่ต้องระวังคือความเข้มงวดเรื่องข้อมูล เพราะ Rust จะบังคับให้เราใส่ข้อมูลให้ครบทุก Field ที่ประกาศไว้ในตอนแรกครับ

Rust

fn main() {
    // สร้าง Instance ชื่อ user1 (ใช้ mut เพื่อให้แก้ไขข้อมูลภายหลังได้)
    let mut user1 = User {
        email: String::from("admin@superdev.com"),
        username: String::from("superdev_admin"),
        active: true,
        sign_in_count: 1,
    };

    // การเข้าถึงข้อมูล: ใช้เครื่องหมายจุด (Dot Notation) เช่น user1.email
    // การแก้ไขข้อมูล: เราเปลี่ยนค่าได้ทันทีเพราะประกาศเป็น mut ไว้
    user1.email = String::from("contact@superdev.com");
    
    println!("User: {} (Email: {})", user1.username, user1.email);
}

ข้อควรรู้เกี่ยวกับความปลอดภัย:

• Immutable by Default: ตามสไตล์ของ Rust ถ้าคุณประกาศแค่ let user1 = ... คุณจะไม่สามารถแก้ไขข้อมูลใน Field ไหนได้เลยหลังจากสร้างเสร็จ

• All or Nothing: ใน Rust เราไม่สามารถเลือกให้ Field ใด Field หนึ่งเป็น mut แยกกันได้ ถ้าจะแก้ ต้องแก้ได้ทั้งก้อน (ทั้ง Instance) เท่านั้นครับ

3. Method: เพิ่มความสามารถให้ Struct

ลำพังแค่เก็บข้อมูลได้ก็นับว่าดีแล้ว แต่สิ่งที่ทำให้ Struct ทรงพลังขึ้นไปอีกขั้นคือการใส่ Method หรือฟังก์ชันที่ผูกติดกับ Struct ลงไปครับ เพื่อให้วัตถุนั้นๆ มีความสามารถในตัวมันเอง

เราจะใช้คีย์เวิร์ด impl (ย่อมาจาก Implementation) เพื่อประกาศว่า "ต่อไปนี้คือความสามารถของ Struct นี้คร้าบ"

Rust

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    // Method สำหรับคำนวณพื้นที่
    // เราใช้ &self เพื่อบอกว่า "ขอยืมอ่านข้อมูลจากตัวเองหน่อยนะ"
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

fn main() {
    let rect = Rectangle { width: 30, height: 50 };
    
    // เรียกใช้งานความสามารถผ่านเครื่องหมายจุด (.)
    println!("พื้นที่สี่เหลี่ยมคือ: {} ตารางหน่วย", rect.area());
}

ทำไมต้องมี &self?

สังเกตไหมครับว่าในพารามิเตอร์เราใส่ &self ลงไป นั่นคือการนำกฎ Borrowing จาก EP.8 มาประยุกต์ใช้:

• มันคือการยืมอ่าน ข้อมูลของตัวเอง (Instance นั้นๆ) มาประมวลผล

• ถ้าเราอยากให้ Method นั้นแก้ไขค่าในตัวเองได้ เราก็แค่เปลี่ยนเป็น &mut self

• นี่คือความสวยงามของ Rust ที่แม้แต่ใน Object-Oriented Style กฎ Ownership ก็ยังตามมาคุ้มครองให้เราเขียนโค้ดได้อย่างปลอดภัยเสมอ!

4. บทสรุปการเดินทางของ Rust The Series

ยินดีด้วยครับ! ตลอด 10 EP ที่ผ่านมา เราได้ร่วมกันวางรากฐานที่สำคัญที่สุดเพื่อก้าวเข้าสู่โลกของ Rust อย่างเต็มตัว โดยเราสามารถสรุปเส้นทางความสำเร็จครั้งนี้ได้ดังนี้ครับ:

• EP.1-3 (The Beginning): การเตรียมอาวุธให้พร้อม ติดตั้งเครื่องมือ และทำความรู้จักกับ Cargo ผู้ช่วยอัจฉริยะที่จะอยู่กับเราไปตลอด

• EP.4-6 (The Core): ทำความเข้าใจพื้นฐานที่ขาดไม่ได้ ทั้งเรื่องตัวแปร, Data Types และการควบคุมทิศทางของโปรแกรม (Control Flow)

• EP.7-9 (The Soul): เจาะลึกหัวใจสำคัญที่ทำให้ Rust แตกต่างจากทุกภาษาในโลกอย่าง Ownership, Borrowing และ Slices

• EP.10 (The Architecture): การนำทุกอย่างมาประกอบร่างเพื่อออกแบบโครงสร้างข้อมูลในสไตล์คุณด้วย Structs

ถึงแม้ซีรีส์ภาคพื้นฐานจะจบลงตรงนี้ แต่การเดินทางในโลกของ Rust เพิ่งเริ่มต้นขึ้นเท่านั้น! ยังมีขุมทรัพย์ความรู้ที่น่าตื่นเต้นอย่าง Enums, Pattern Matching, Traits และ Error Handling รอให้คุณมาพิชิตในลำดับถัดไปครับ

"การที่คุณเริ่มคุยกับ Compiler ของ Rust รู้เรื่องในวันนี้ คือก้าวแรกสู่การเป็นนักพัฒนาที่เขียนซอฟต์แวร์ได้ปลอดภัยและมีประสิทธิภาพสูงที่สุดคนหนึ่งครับ"

ส่งท้ายจากใจทีมงาน

ขอขอบคุณเพื่อนๆ ทุกคนที่ติดตาม Rust The Series เดินทางร่วมกันมาจนจบภาคพื้นฐานนะครับ!

เราหวังเป็นอย่างยิ่งว่าซีรีส์นี้จะช่วยพังทลายกำแพงความเชื่อที่ว่า "Rust เขียนยาก" ให้กลายเป็นความสนุกและความมั่นใจในการเรียนรู้แทน สำหรับพวกเราแล้ว ความปลอดภัยและความเร็วของ Rust ไม่ใช่แค่ฟีเจอร์ของภาษา แต่คือศิลปะในการเขียนโปรแกรมที่ยอดเยี่ยมครับ

บทความหน้าเราจะมีโปรเจกต์ใหม่ๆ มาฝาก หรือจะพาคุณก้าวข้ามขีดจำกัดไปสู่ Rust ในระดับ Advanced แค่ไหน... ต้องรอติดตามให้ดีครับ!

🎯 ติดตามความรู้สาย Dev แบบสุดจัดได้ที่ Superdev Academy: ไม่อยากพลาดบทความเทคนิคเชิงลึกและอัปเดตเทคโนโลยีใหม่ๆ จากเรา ติดตามได้ทุกช่องทางที่นี่ครับ:

• 🔵 Facebook: Superdev Academy Thailand (อัปเดตข่าวสารและบทความใหม่)

• 🎬 YouTube: Superdev Academy Channel (ติวเข้มแบบวิดีโอ)

• 📸 Instagram: @superdevacademy (เกร็ดความรู้สั้นๆ และเบื้องหลังการทำงาน)

• 🎬 TikTok: @superdevacademy (Tips & Tricks ฉบับย่อยง่าย)

• 🌐 Website: superdevacademy.com (คลังบทความและคอร์สเรียนฉบับเต็ม)

แล้วเจอกันในซีรีส์ถัดไปครับ... Happy Coding! 🦀✨