การนิยามและสร้างอินสแตนซ์ของ struct
struct มีความคล้ายคลึงกับทูเพิล (tuple) ซึ่งเราได้กล่าวถึงในหัวข้อ “ชนิดทูเพิล” ตรงที่ทั้งสองสามารถจัดเก็บค่าข้อมูลที่เกี่ยวข้องกันได้หลายค่า และสมาชิกแต่ละตัวสามารถมีชนิดข้อมูลที่แตกต่างกันได้ แต่จุดที่ต่างจากทูเพิลคือ ใน struct คุณจะสามารถตั้งชื่อให้กับข้อมูลแต่ละชิ้นได้ เพื่อระบุความหมายของค่านั้นๆ ไว้อย่างชัดเจน การมีชื่อกำกับทำให้ struct มีความยืดหยุ่นกว่าทูเพิลมาก โดยคุณไม่จำเป็นต้องพึ่งพาลำดับก่อนหลังของข้อมูลในการเข้าถึงหรือระบุค่าต่างๆ ของอินสแตนซ์ (instance) อีกต่อไป
ในการนิยาม struct เราจะขึ้นต้นด้วยคีย์เวิร์ด struct ตามด้วยชื่อที่ต้องการตั้งให้กับ struct นั้น โดยชื่อของ struct ควรสื่อถึงความหมายและความสำคัญของกลุ่มข้อมูลที่ถูกรวมเข้าไว้ด้วยกัน จากนั้นภายในเครื่องหมายวงเล็บปีกกา เราจะระบุชื่อและชนิดข้อมูลของข้อมูลแต่ละชิ้น ซึ่งเราเรียกว่า ฟิลด์ (field) ตัวอย่างเช่น ลิสติ้ง 5-1 แสดงการนิยาม struct สำหรับจัดเก็บข้อมูลเกี่ยวกับบัญชีผู้ใช้
struct User {
active: bool,
username: String,
email: String,
sign_in_count: u64,
}
fn main() {}
เมื่อต้องการนำ struct ไปใช้งานหลังจากนิยามไว้แล้ว เราจะสร้าง อินสแตนซ์ (instance) ของ struct นั้นขึ้นมาโดยการกำหนดค่าจริงให้กับแต่ละฟิลด์ การสร้างอินสแตนซ์ทำได้โดยระบุชื่อของ struct ตามด้วยเครื่องหมายวงเล็บปีกกาที่บรรจุคู่ key: value โดยที่คีย์ (key) คือชื่อของฟิลด์ และค่า (value) คือข้อมูลที่เราต้องการบันทึกไว้ในฟิลด์นั้นๆ ทั้งนี้เราไม่จำเป็นต้องเรียงลำดับฟิลด์ให้ตรงกับตอนที่ประกาศไว้ใน struct แต่อย่างใด กล่าวอีกนัยหนึ่ง การนิยาม struct เปรียบเสมือนแบบพิมพ์เขียวทั่วไปของชนิดข้อมูล และอินสแตนซ์ก็คือการนำข้อมูลจริงไปเติมลงในแบบพิมพ์เขียวนั้นเพื่อสร้างเป็นค่าข้อมูลขึ้นมา ตัวอย่างเช่น เราสามารถประกาศข้อมูลของผู้ใช้รายหนึ่งได้ดังแสดงในลิสติ้ง 5-2
struct User {
active: bool,
username: String,
email: String,
sign_in_count: u64,
}
fn main() {
let user1 = User {
active: true,
username: String::from("someusername123"),
email: String::from("someone@example.com"),
sign_in_count: 1,
};
}
เมื่อต้องการเข้าถึงค่าในฟิลด์ใดฟิลด์หนึ่งของ struct เราจะใช้สัญกรณ์จุด (dot notation) ตัวอย่างเช่น หากต้องการอ่านที่อยู่อีเมลของผู้ใช้รายนี้ เราจะเขียนว่า user1.email และหากอินสแตนซ์นั้นถูกประกาศให้เป็นตัวแปรแบบแก้ไขได้ (mutable) เราจะสามารถแก้ไขค่าในฟิลด์ได้โดยใช้สัญกรณ์จุดควบคู่กับการกำหนดค่าใหม่ลงไป ลิสติ้ง 5-3 แสดงตัวอย่างการเปลี่ยนค่าในฟิลด์ email ของอินสแตนซ์ User ที่แก้ไขได้
struct User {
active: bool,
username: String,
email: String,
sign_in_count: u64,
}
fn main() {
let mut user1 = User {
active: true,
username: String::from("someusername123"),
email: String::from("someone@example.com"),
sign_in_count: 1,
};
user1.email = String::from("anotheremail@example.com");
}
โปรดสังเกตว่าการกำหนดให้แก้ไขค่าได้นั้นจะต้องกระทำกับอินสแตนซ์ทั้งตัว เพราะ Rust ไม่อนุญาตให้เรากำหนดความสามารถในการแก้ไขค่าเฉพาะบางฟิลด์ได้ และเช่นเดียวกับนิพจน์ (expression) ทั่วไป เราสามารถสร้างอินสแตนซ์ใหม่ของ struct เป็นนิพจน์สุดท้ายในเนื้อหาของฟังก์ชัน เพื่อส่งคืนอินสแตนซ์ใหม่นั้นออกมาจากฟังก์ชันได้โดยปริยาย
ลิสติ้ง 5-4 แสดงฟังก์ชัน build_user ซึ่งจะส่งคืนอินสแตนซ์ของ User ที่มีอีเมลและชื่อผู้ใช้ตามที่ระบุเข้ามา โดยกำหนดให้ฟิลด์ active มีค่าเป็น true และฟิลด์ sign_in_count มีค่าเป็น 1
struct User {
active: bool,
username: String,
email: String,
sign_in_count: u64,
}
fn build_user(email: String, username: String) -> User {
User {
active: true,
username: username,
email: email,
sign_in_count: 1,
}
}
fn main() {
let user1 = build_user(
String::from("someone@example.com"),
String::from("someusername123"),
);
}
การตั้งชื่อพารามิเตอร์ของฟังก์ชันให้ตรงกับชื่อฟิลด์ของ struct ถือเป็นเรื่องที่สมเหตุสมผลและสื่อความหมายได้ดี แต่การต้องพิมพ์ชื่อตัวแปร email และ username ซ้ำๆ เช่น email: email นั้นค่อนข้างซ้ำซ้อน หาก struct มีฟิลด์มากกว่านี้ การพิมพ์ชื่อซ้ำก็จะยิ่งน่ารำคาญมากขึ้น ซึ่งโชคดีที่ Rust มีรูปแบบการเขียนย่อที่สะดวกสบายเตรียมไว้ให้!
การใช้รูปแบบย่อของฟิลด์
เนื่องจากชื่อพารามิเตอร์และชื่อฟิลด์ของ struct มีชื่อเดียวกันทุกประการในลิสติ้ง 5-4 เราจึงสามารถใช้ไวยากรณ์ รูปแบบย่อสำหรับกำหนดค่าเริ่มต้นฟิลด์ (field init shorthand) เพื่อเขียนฟังก์ชัน build_user ใหม่ให้ทำงานเหมือนเดิมทุกประการ แต่ไม่ต้องพิมพ์ username และ email ซ้ำ ดังแสดงในลิสติ้ง 5-5
struct User {
active: bool,
username: String,
email: String,
sign_in_count: u64,
}
fn build_user(email: String, username: String) -> User {
User {
active: true,
username,
email,
sign_in_count: 1,
}
}
fn main() {
let user1 = build_user(
String::from("someone@example.com"),
String::from("someusername123"),
);
}
ในตัวอย่างนี้ เรากำลังสร้างอินสแตนซ์ใหม่ของ struct User ที่มีฟิลด์ชื่อ email โดยต้องการนำค่าจากพารามิเตอร์ email ในฟังก์ชัน build_user มากำหนดให้กับฟิลด์นี้ และเนื่องจากทั้งสองมีชื่อตรงกัน เราจึงสามารถเขียนเพียงแค่ email สั้นๆ แทนที่จะต้องเขียน email: email ได้ทันที
การสร้างอินสแตนซ์ด้วยไวยากรณ์อัปเดต struct
บ่อยครั้งที่เราต้องการสร้างอินสแตนซ์ใหม่ของ struct โดยคัดลอกค่าส่วนใหญ่มาจากอินสแตนซ์เดิมของชนิดข้อมูลเดียวกัน และต้องการเปลี่ยนค่าเพียงแค่บางฟิลด์เท่านั้น ในสถานการณ์นี้ เราสามารถนำ ไวยากรณ์อัปเดต struct (struct update syntax) มาใช้งานได้
ขั้นแรก ลิสติ้ง 5-6 แสดงวิธีสร้างอินสแตนซ์ใหม่ของ User ในตัวแปร user2 ด้วยวิธีมาตรฐานโดยไม่ใช้ไวยากรณ์อัปเดต โดยเรากำหนดค่าใหม่ให้กับฟิลด์ email แต่ฟิลด์ที่เหลือทั้งหมดจะดึงค่ามาจาก user1 ที่สร้างไว้ในลิสติ้ง 5-2
struct User {
active: bool,
username: String,
email: String,
sign_in_count: u64,
}
fn main() {
// --snip--
let user1 = User {
email: String::from("someone@example.com"),
username: String::from("someusername123"),
active: true,
sign_in_count: 1,
};
let user2 = User {
active: user1.active,
username: user1.username,
email: String::from("another@example.com"),
sign_in_count: user1.sign_in_count,
};
}
เมื่อเปลี่ยนมาใช้ไวยากรณ์อัปเดต struct เราจะสามารถเขียนโค้ดที่ให้ผลลัพธ์แบบเดียวกันได้อย่างกระชับยิ่งขึ้น ดังแสดงในลิสติ้ง 5-7 โดยเครื่องหมาย .. เป็นการระบุว่าฟิลด์ที่เหลือทั้งหมดที่ไม่ได้กำหนดค่าไว้อย่างชัดเจน ให้นำค่ามาจากฟิลด์ที่ตรงกันในอินสแตนซ์ที่ระบุ
struct User {
active: bool,
username: String,
email: String,
sign_in_count: u64,
}
fn main() {
// --snip--
let user1 = User {
email: String::from("someone@example.com"),
username: String::from("someusername123"),
active: true,
sign_in_count: 1,
};
let user2 = User {
email: String::from("another@example.com"),
..user1
};
}
โค้ดในลิสติ้ง 5-7 จะสร้างอินสแตนซ์ใน user2 ที่มีค่าในฟิลด์ email ต่างออกไป แต่มีค่าในฟิลด์ username, active และ sign_in_count เหมือนกับ user1 ทุกประการ โดยคำสั่ง ..user1 จะต้องวางไว้ท้ายสุดเสมอ เพื่อบ่งชี้ว่าฟิลด์ที่เหลือให้รับค่ามาจาก user1 แต่เราสามารถเลือกกำหนดค่าให้กับฟิลด์ต่างๆ ล่วงหน้าได้มากเท่าที่ต้องการในลำดับใดก็ได้ โดยไม่จำเป็นต้องเรียงตามลำดับฟิลด์ที่นิยามไว้ใน struct
โปรดสังเกตว่าไวยากรณ์อัปเดต struct ใช้เครื่องหมาย = เช่นเดียวกับการกำหนดค่าทั่วไป จึงทำให้เกิดการย้ายค่า (move) ของข้อมูลขึ้น ดังที่เราได้เรียนรู้กันไปแล้วในหัวข้อ “ตัวแปรและข้อมูลที่ปฏิสัมพันธ์กันด้วยการย้ายค่า” ในตัวอย่างนี้ เราจะไม่สามารถนำตัวแปร user1 มาใช้งานต่อได้อีกหลังจากสร้าง user2 ไปแล้ว เนื่องจากค่า String ในฟิลด์ username ของ user1 ได้ถูกย้ายเข้าไปยัง user2 เรียบร้อยแล้ว แต่หากเรากำหนดค่า String ใหม่ให้กับ user2 ทั้งในฟิลด์ email และ username แล้วดึงมาเฉพาะค่าในฟิลด์ active และ sign_in_count จาก user1 เท่านั้น ตัวแปร user1 จะยังคงสามารถใช้งานต่อไปได้หลังจากสร้าง user2 เนื่องจากทั้ง active และ sign_in_count ต่างเป็นชนิดข้อมูลที่อิมพลีเมนต์เทรต Copy พฤติกรรมจึงเป็นไปตามที่เราได้ศึกษาในหัวข้อ “ข้อมูลบนสแตกเท่านั้น: การคัดลอกค่า” และนอกจากนี้เรายังคงสามารถเข้าถึง user1.email ในตัวอย่างนี้ได้ เพราะค่าของมันไม่ได้ถูกย้ายออกไปจาก user1
การสร้างชนิดข้อมูลที่แตกต่างกันด้วยทูเพิล struct
Rust ยังรองรับการสร้าง struct ที่มีรูปแบบคล้ายทูเพิล ซึ่งเรียกว่า ทูเพิล struct (tuple struct) โดยทูเพิล struct จะได้รับประโยชน์จากการมีชื่อของชนิดข้อมูลเพื่อบ่งบอกความหมาย แต่จะไม่มีชื่อกำกับฟิลด์แต่ละตัว โดยจะมีเพียงชนิดข้อมูลของแต่ละฟิลด์เท่านั้น ทูเพิล struct มีประโยชน์อย่างยิ่งเมื่อคุณต้องการตั้งชื่อให้กับทูเพิลทั้งชุดเพื่อสร้างเป็นชนิดข้อมูลใหม่ที่แตกต่างจากทูเพิลอื่นๆ และในกรณีที่การตั้งชื่อให้กับทุกๆ ฟิลด์เหมือนใน struct ทั่วไปดูจะเยิ่นเย้อหรือซ้ำซ้อนเกินไป
ในการนิยามทูเพิล struct ให้เริ่มต้นด้วยคีย์เวิร์ด struct ตามด้วยชื่อของ struct และตามด้วยชนิดข้อมูลของสมาชิกในทูเพิล ตัวอย่างเช่น เรานิยามและใช้งานทูเพิล struct สองตัวชื่อ Color และ Point:
struct Color(i32, i32, i32);
struct Point(i32, i32, i32);
fn main() {
let black = Color(0, 0, 0);
let origin = Point(0, 0, 0);
}
โปรดสังเกตว่าค่า black และ origin เป็นคนละชนิดข้อมูลกันอย่างสิ้นเชิง เนื่องจากพวกมันเป็นอินสแตนซ์ของทูเพิล struct คนละตัวกัน struct แต่ละตัวที่คุณนิยามขึ้นมาจะถือเป็นชนิดข้อมูลเฉพาะของตนเองเสมอ แม้ว่าฟิลด์ภายในจะมีชนิดข้อมูลเหมือนกันทุกประการก็ตาม ตัวอย่างเช่น ฟังก์ชันที่รับพารามิเตอร์ชนิด Color จะไม่สามารถรับอาร์กิวเมนต์ชนิด Point ได้ แม้ว่าชนิดข้อมูลทั้งสองจะประกอบขึ้นจากค่า i32 สามตัวเหมือนกันก็ตาม ส่วนการทำงานอื่นๆ ของอินสแตนซ์ทูเพิล struct จะเหมือนกับทูเพิลทั่วไป คือคุณสามารถกระจายโครงสร้างข้อมูล (destructuring) ออกเป็นชิ้นส่วนย่อยๆ ได้ และสามารถใช้เครื่องหมาย . ตามด้วยตัวเลขดัชนีเพื่อเข้าถึงสมาชิกแต่ละตัวได้ แต่จุดที่ต่างจากทูเพิลคือ ทูเพิล struct กำหนดให้คุณต้องระบุชื่อชนิดข้อมูลของ struct เมื่อต้องการกระจายโครงสร้าง เช่น เราจะเขียน let Point(x, y, z) = origin; เพื่อกระจายค่าใน origin ออกมาเป็นตัวแปร x, y และ z
การนิยาม struct ที่คล้ายยูนิต
คุณยังสามารถนิยาม struct ที่ไม่มีฟิลด์ข้อมูลใดๆ เลยได้ด้วย! เราเรียกโครงสร้างเหล่านี้ว่า struct ที่คล้ายยูนิต (unit-like struct) เนื่องจากมันทำงานคล้ายคลึงกับชนิดข้อมูลยูนิต () ที่เราเคยกล่าวถึงในหัวข้อ “ชนิดทูเพิล” โดย struct ที่คล้ายยูนิตจะมีประโยชน์อย่างมากเมื่อคุณจำเป็นต้องอิมพลีเมนต์เทรต (trait) ให้กับชนิดข้อมูลบางชนิด แต่ไม่มีข้อมูลใดๆ ที่จำเป็นต้องเก็บไว้ในตัวชนิดข้อมูลนั้น ซึ่งเราจะเจาะลึกเรื่องเทรตในบทที่ 10 ต่อไป ตัวอย่างต่อไปนี้แสดงการประกาศและสร้างอินสแตนซ์ของ struct แบบยูนิตชื่อ AlwaysEqual:
struct AlwaysEqual;
fn main() {
let subject = AlwaysEqual;
}
ในการนิยาม AlwaysEqual เราใช้คีย์เวิร์ด struct ตามด้วยชื่อที่ต้องการ แล้วปิดท้ายด้วยเครื่องหมายอัฒภาคได้ทันที โดยไม่ต้องมีทั้งวงเล็บปีกกาหรือวงเล็บกลม! จากนั้นเราสามารถสร้างอินสแตนซ์ของ AlwaysEqual มอบให้กับตัวแปร subject ได้ในทำนองเดียวกัน คือระบุเพียงแค่ชื่อที่เรานิยามไว้โดยไม่ต้องใส่วงเล็บใดๆ ลองจินตนาการว่าในภายหลังเราจะอิมพลีเมนต์พฤติกรรมให้กับชนิดข้อมูลนี้ โดยกำหนดให้อินสแตนซ์ของ AlwaysEqual มีค่าเท่ากับทุกอินสแตนซ์ของชนิดข้อมูลอื่นเสมอ เช่น เพื่อให้ได้ผลลัพธ์ที่คาดเดาได้แน่นอนสำหรับการทดสอบ (testing) เราก็ไม่จำเป็นต้องเก็บข้อมูลใดๆ ไว้ในตัวแปรเพื่อทำงานดังกล่าวเลย! คุณจะได้เห็นวิธีนิยามและอิมพลีเมนต์เทรตให้กับชนิดข้อมูลต่างๆ รวมถึง struct ที่คล้ายยูนิตอย่างละเอียดในบทที่ 10
ความเป็นเจ้าของข้อมูลใน struct
ในการนิยาม struct
Userในลิสติ้ง 5-1 เราเลือกใช้ชนิดข้อมูลStringที่ถือครองความเป็นเจ้าของค่าข้อมูล แทนที่จะใช้สตริงสไลซ์&strซึ่งเป็นการตัดสินใจโดยเจตนา เพราะเราต้องการให้อินสแตนซ์แต่ละตัวของstructนี้เป็นเจ้าของข้อมูลทั้งหมดของมันอย่างสมบูรณ์ และให้ข้อมูลนั้นคงอยู่ตราบเท่าที่อินสแตนซ์ของstructยังคงใช้งานได้ในความเป็นจริง
structสามารถจัดเก็บการอ้างอิง (reference) ไปยังข้อมูลที่เป็นของตัวแปรอื่นได้เช่นกัน แต่การทำเช่นนั้นจะต้องใช้สิ่งที่เรียกว่า ไลฟ์ไทม์ (lifetime) ซึ่งเป็นฟีเจอร์ขั้นสูงของ Rust ที่เราจะพูดถึงในบทที่ 10 โดยไลฟ์ไทม์จะช่วยรับประกันว่าข้อมูลที่structอ้างอิงไปถึงจะยังคงมีตัวตนอยู่เสมอ ตราบใดที่structนั้นยังคงใช้งานอยู่ หากคุณพยายามเก็บเรเฟอเรนซ์ไว้ในstructโดยไม่ระบุไลฟ์ไทม์กำกับไว้ ดังเช่นตัวอย่างใน src/main.rs ต่อไปนี้ โค้ดจะไม่สามารถคอมไพล์ผ่านได้:struct User { active: bool, username: &str, email: &str, sign_in_count: u64, } fn main() { let user1 = User { active: true, username: "someusername123", email: "someone@example.com", sign_in_count: 1, }; }คอมไพเลอร์จะแจ้งเตือนว่าจำเป็นต้องระบุไลฟ์ไทม์:
$ cargo run Compiling structs v0.1.0 (file:///projects/structs) error[E0106]: missing lifetime specifier --> src/main.rs:3:15 | 3 | username: &str, | ^ expected named lifetime parameter | help: consider introducing a named lifetime parameter | 1 ~ struct User<'a> { 2 | active: bool, 3 ~ username: &'a str, | error[E0106]: missing lifetime specifier --> src/main.rs:4:12 | 4 | email: &str, | ^ expected named lifetime parameter | help: consider introducing a named lifetime parameter | 1 ~ struct User<'a> { 2 | active: bool, 3 | username: &str, 4 ~ email: &'a str, | For more information about this error, try `rustc --explain E0106`. error: could not compile `structs` (bin "structs") due to 2 previous errorsในบทที่ 10 เราจะได้เรียนรู้วิธีแก้ไขข้อผิดพลาดเหล่านี้ เพื่อให้คุณสามารถจัดเก็บเรเฟอเรนซ์ไว้ใน
structได้อย่างถูกต้อง แต่สำหรับในตอนนี้ เราจะแก้ไขปัญหาโดยการเลือกใช้ชนิดข้อมูลที่ถือครองความเป็นเจ้าของค่า เช่นStringแทนที่จะใช้เรเฟอเรนซ์อย่าง&str