การกำหนดและใช้งานโครงสร้าง
สร้างโครงสร้างข้อมูลแบบกำหนดเองด้วยโครงสร้าง รวมถึงโครงสร้างแบบทูเพิลและโครงสร้างคล้ายหน่วย เพื่อจัดกลุ่มข้อมูลที่เกี่ยวข้องกัน
การกำหนดและใช้งานโครงสร้าง เป็นบทเรียน 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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- การกำหนดและใช้งานโครงสร้าง
- การใช้ enum สำหรับชนิดข้อมูลแบบกำหนดเอง
- การจับคู่รูปแบบอันทรงพลัง