0Pricing
Learn Rust Coding · บทเรียน

การกำหนดและใช้งานโครงสร้าง

สร้างโครงสร้างข้อมูลแบบกำหนดเองด้วยโครงสร้าง รวมถึงโครงสร้างแบบทูเพิลและโครงสร้างคล้ายหน่วย เพื่อจัดกลุ่มข้อมูลที่เกี่ยวข้องกัน

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

ทำความรู้จักโครงสร้าง: ชนิดข้อมูลแบบกำหนดเอง

ใน Rust โครงสร้าง (ย่อมาจาก structures) เป็นวิธีสร้างชนิดข้อมูลแบบกำหนดเอง ซึ่งช่วยให้คุณตั้งชื่อและจัดกลุ่มค่าที่เกี่ยวข้องกันหลายค่าไว้ด้วยกันอย่างมีความหมาย

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

วิธีนี้ช่วยจัดระเบียบข้อมูลอย่างเป็นเหตุเป็นผล และทำให้โค้ดอ่านและบำรุงรักษาได้ง่ายขึ้น

การกำหนดโครงสร้างแบบคลาสสิก

โครงสร้างประเภทที่พบบ่อยที่สุดคือโครงสร้างแบบคลาสสิก ซึ่งคุณตั้งชื่อข้อมูลแต่ละชิ้นที่เรียกว่าฟิลด์ ต่อไปนี้คือวิธีกำหนดโครงสร้าง:

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    // This code only defines the struct blueprint.
    // No actual user has been created yet!
    println!("Struct 'User' blueprint defined.");
}

การสร้างอินสแตนซ์ของโครงสร้าง

เมื่อกำหนดโครงสร้างแล้ว คุณสามารถสร้างอินสแตนซ์จริงของโครงสร้างนั้นได้ แต่ละอินสแตนซ์จะเก็บค่าเฉพาะสำหรับฟิลด์ของตน คุณสร้างอินสแตนซ์ได้โดยระบุค่าจริงให้กับแต่ละฟิลด์

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    let user1 = User {
        email: String::from("alice@example.com"),
        username: String::from("alice123"),
        active: true,
        sign_in_count: 1,
    };
    println!("User instance created!");
}

การเข้าถึงฟิลด์ของโครงสร้าง

หากต้องการดึงข้อมูลออกจากอินสแตนซ์ของโครงสร้าง ให้ใช้การเขียนแบบจุด เพียงพิมพ์ชื่ออินสแตนซ์ ตามด้วยจุด (.) แล้วจึงตามด้วยชื่อฟิลด์

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    let user1 = User {
        email: String::from("alice@example.com"),
        username: String::from("alice123"),
        active: true,
        sign_in_count: 1,
    };
    println!("User's username: {}", user1.username);
    println!("User's email: {}", user1.email);
}

ความสามารถในการแก้ไขกับโครงสร้าง

เช่นเดียวกับตัวแปรทั่วไป อินสแตนซ์ของโครงสร้างทั้งอินสแตนซ์สามารถกำหนดให้แก้ไขได้ด้วยคีย์เวิร์ด mut หากอินสแตนซ์แก้ไขได้ ฟิลด์ทั้งหมดของอินสแตนซ์ก็สามารถเปลี่ยนแปลงได้

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

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    let mut user1 = User {
        email: String::from("alice@example.com"),
        username: String::from("alice123"),
        active: true,
        sign_in_count: 1,
    };
    
    println!("Old email: {}", user1.email);
    user1.email = String::from("new_alice@example.com");
    println!("New email: {}", user1.email);
}

โครงสร้างทูเพิล: ฟิลด์ที่ไม่มีชื่อ

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

ตัวอย่างเช่น Color(i32, i32, i32) คือทูเพิลที่มีชื่อ ซึ่งจัดกลุ่มจำนวนเต็มสามค่าไว้ด้วยกัน

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

fn main() {
    let black = Color(0, 0, 0);
    let origin = Point(0, 0, 0);
    println!("Tuple structs 'Color' and 'Point' defined.");
}

การใช้โครงสร้างทูเพิล

การสร้างอินสแตนซ์ของโครงสร้างทูเพิลคล้ายกับการสร้างทูเพิลทั่วไป หากต้องการเข้าถึงค่าภายใน ให้ใช้การเขียนแบบจุดพร้อมดัชนี โดยเริ่มจาก 0

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

fn main() {
    let black = Color(0, 0, 0);
    let origin = Point(0, 0, 0);

    println!("Black color: R={}, G={}, B={}", black.0, black.1, black.2);
    println!("Origin point: X={}, Y={}, Z={}", origin.0, origin.1, origin.2);
}

โครงสร้างคล้ายยูนิต: ตัวทำเครื่องหมาย

คุณยังสามารถกำหนดโครงสร้างที่ไม่มีฟิลด์เลยได้ โครงสร้างเหล่านี้เรียกว่าโครงสร้างคล้ายยูนิต เพราะมีพฤติกรรมคล้ายกับชนิดยูนิต ()

โครงสร้างเหล่านี้มักใช้เป็นตัวทำเครื่องหมายเพื่อใช้เทรตหนึ่งกับชนิดข้อมูล โดยที่ข้อมูลเองไม่สำคัญ

struct AlwaysTrue;

fn main() {
    let subject = AlwaysTrue;
    // Unit-like structs don't store data directly,
    // but they can be instantiated and used as types.
    println!("Unit-like struct 'AlwaysTrue' created.");
}

ไวยากรณ์การอัปเดตโครงสร้าง

หากคุณต้องการสร้างอินสแตนซ์โครงสร้างใหม่โดยอ้างอิงจากอินสแตนซ์เดิม แต่ต้องการเปลี่ยนค่าเพียงบางฟิลด์ Rust มีไวยากรณ์การอัปเดตโครงสร้าง (..) ที่สะดวกให้ใช้

ไวยากรณ์นี้จะย้ายฟิลด์ที่เหลือจากอินสแตนซ์ที่ระบุ ดังนั้นจึงไม่สามารถใช้อินสแตนซ์เดิมได้อีก หากอินสแตนซ์นั้นมีฟิลด์ที่ใช้ Copy

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    let user1 = User {
        email: String::from("alice@example.com"),
        username: String::from("alice123"),
        active: true,
        sign_in_count: 1,
    };

    let user2 = User {
        email: String::from("bob@example.com"),
        username: String::from("bob456"),
        ..user1 // Copy remaining fields from user1
    };

    println!("User 2 email: {}", user2.email);
    println!("User 2 active: {}", user2.active);
    // user1.username is now moved, so user1 can't be used here.
}

แบบทดสอบโครงสร้าง

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

ทบทวน: ภาพรวมโครงสร้าง

คุณได้เรียนรู้วิธีกำหนดและใช้โครงสร้างใน Rust แล้ว

  • โครงสร้างแบบคลาสสิกจัดกลุ่มฟิลด์ที่มีชื่อเพื่อสร้างชนิดข้อมูลแบบกำหนดเอง
  • โครงสร้างทูเพิลคือทูเพิลที่มีชื่อ เหมาะสำหรับกรณีที่ไม่จำเป็นต้องตั้งชื่อฟิลด์โดยเฉพาะ
  • โครงสร้างคล้ายยูนิตไม่มีฟิลด์และทำหน้าที่เป็นตัวทำเครื่องหมาย
  • คุณสามารถกำหนดอินสแตนซ์ของโครงสร้างให้เป็น mut เพื่อให้แก้ไขฟิลด์ได้
  • ไวยากรณ์ .. ช่วยสร้างอินสแตนซ์ใหม่จากอินสแตนซ์เดิม

โครงสร้างเป็นพื้นฐานสำคัญสำหรับการจัดระเบียบข้อมูลที่เกี่ยวข้องกันในโปรแกรม Rust ทำให้โค้ดมีโครงสร้างและอ่านง่ายขึ้น

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

บทเรียน “การกำหนดและใช้งานโครงสร้าง” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “การกำหนดและใช้งานโครงสร้าง”

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

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

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

บทเรียน “การกำหนดและใช้งานโครงสร้าง” ใช้เวลานานแค่ไหน

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

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

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

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

  1. การกำหนดและใช้งานโครงสร้าง
  2. การใช้ enum สำหรับชนิดข้อมูลแบบกำหนดเอง
  3. การจับคู่รูปแบบอันทรงพลัง
← กลับไปที่ Learn Rust Coding