ควบคุมสโคปและความเป็นส่วนตัวด้วยมอดูล
ในหัวข้อนี้ เราจะมาพูดคุยเกี่ยวกับมอดูล (modules) รวมถึงองค์ประกอบอื่นๆ ในระบบมอดูล ได้แก่ พาธ (paths) ซึ่งช่วยให้เราสามารถระบุชื่อเพื่ออ้างอิงถึงไอเทมต่างๆ ได้, คีย์เวิร์ด use ซึ่งทำหน้าที่นำพาธเข้ามาไว้ในสโคป (scope) และคีย์เวิร์ด pub ที่ใช้กำหนดให้ไอเทมเปิดเผยเป็นสาธารณะ (public) นอกจากนี้ เรายังจะได้เรียนรู้เกี่ยวกับคีย์เวิร์ด as, การใช้งานแพ็กเกจภายนอก และตัวดำเนินการแบบ glob (*)
แผ่นสรุปมอดูล
ก่อนที่เราจะเจาะลึกในรายละเอียดของมอดูลและพาธ เราได้เตรียมคู่มือสรุปฉบับย่อเกี่ยวกับหลักการทำงานของมอดูล, พาธ, คีย์เวิร์ด use และคีย์เวิร์ด pub ในมุมมองของคอมไพเลอร์ รวมถึงแนวทางที่นักพัฒนาส่วนใหญ่นิยมใช้จัดโครงสร้างโค้ดเอาไว้ให้ แม้ว่าเราจะค่อยๆ ทยอยอธิบายตัวอย่างของแต่ละกฎเกณฑ์ตลอดทั้งบทนี้ แต่หัวข้อนี้ก็ถือเป็นจุดอ้างอิงที่ดีเยี่ยมสำหรับกลับมาทบทวนการทำงานของมอดูลในภายหลัง
- เริ่มต้นจากรากของเครต (Start from the crate root): ในการคอมไพล์เครต คอมไพเลอร์จะเริ่มต้นค้นหาโค้ดจากไฟล์รากของเครตเป็นอันดับแรกเสมอ (โดยปกติคือไฟล์ src/lib.rs สำหรับเครตไลบรารี และ src/main.rs สำหรับเครตไบนารี)
- การประกาศมอดูล (Declaring modules): ในไฟล์รากของเครต คุณสามารถประกาศมอดูลใหม่ๆ ขึ้นมาได้ เช่น หากคุณประกาศมอดูล “garden” ด้วยคำสั่ง
mod garden;ตัวคอมไพเลอร์จะมองหาโค้ดของมอดูลนั้นตามตำแหน่งต่างๆ ดังนี้:- เขียนแบบอินไลน์ (inline) ภายในวงเล็บปีกกาที่เขียนแทนเครื่องหมายอัฒภาค (semicolon) ต่อท้าย
mod garden - ในไฟล์ src/garden.rs
- ในไฟล์ src/garden/mod.rs (รูปแบบเก่าที่ยังคงรองรับ)
- เขียนแบบอินไลน์ (inline) ภายในวงเล็บปีกกาที่เขียนแทนเครื่องหมายอัฒภาค (semicolon) ต่อท้าย
- การประกาศมอดูลย่อย (Declaring submodules): ภายในไฟล์อื่นๆ ที่ไม่ใช่ไฟล์รากของเครต คุณสามารถประกาศมอดูลย่อย (submodules) ได้ เช่น คุณอาจประกาศ
mod vegetables;ไว้ในไฟล์ src/garden.rs ตัวคอมไพเลอร์จะมองหาโค้ดของมอดูลย่อยดังกล่าวภายในไดเรกทอรีที่ตั้งชื่อตามมอดูลแม่ ในตำแหน่งต่างๆ ดังนี้:- เขียนแบบอินไลน์ ต่อท้าย
mod vegetablesภายในวงเล็บปีกกาแทนการใช้อัฒภาค - ในไฟล์ src/garden/vegetables.rs
- ในไฟล์ src/garden/vegetables/mod.rs (รูปแบบเก่าที่ยังคงรองรับ)
- เขียนแบบอินไลน์ ต่อท้าย
- พาธสำหรับอ้างถึงโค้ดในมอดูล (Paths to code in modules): เมื่อมอดูลใดถูกรวมเข้าเป็นส่วนหนึ่งของเครตแล้ว คุณสามารถอ้างอิงถึงโค้ดในมอดูลนั้นจากจุดใดก็ได้ภายในเครตเดียวกัน ตราบใดที่กฎการเข้าถึง (privacy rules) อนุญาต โดยใช้พาธที่ชี้ไปยังโค้ดนั้น เช่น ชนิดข้อมูล
Asparagusในมอดูลย่อย garden vegetables สามารถอ้างอิงผ่านพาธcrate::garden::vegetables::Asparagus - สถานะส่วนตัวเทียบกับสาธารณะ (Private vs. public): โค้ดที่อยู่ภายในมอดูลจะมีสถานะเป็นแบบส่วนตัว (private) จากมอดูลแม่โดยปริยาย หากต้องการเปิดให้มอดูลเข้าถึงได้จากภายนอก จะต้องประกาศด้วย
pub modแทนที่จะเป็นmodธรรมดา และหากต้องการเปิดให้ไอเทมที่อยู่ภายในมอดูลสาธารณะนั้นเป็นสาธารณะด้วย ก็จะต้องเติมคีย์เวิร์ดpubไว้ข้างหน้าการประกาศไอเทมเหล่านั้นด้วยเช่นกัน - คีย์เวิร์ด
use: ภายในสโคปใดๆ คีย์เวิร์ดuseจะช่วยสร้างทางลัดไปยังไอเทมต่างๆ เพื่อลดความซ้ำซ้อนในการพิมพ์พาธที่ยาว ในสโคปใดก็ตามที่สามารถอ้างถึงcrate::garden::vegetables::Asparagusได้ คุณสามารถสร้างทางลัดขึ้นมาได้ด้วยคำสั่งuse crate::garden::vegetables::Asparagus;และหลังจากนั้น คุณก็เพียงแค่เขียนชื่อAsparagusสั้นๆ เพื่อเรียกใช้งานชนิดข้อมูลนั้นในสโคปได้ทันที
ในตัวอย่างนี้ เราได้สร้างเครตไบนารีชื่อ backyard ขึ้นมาเพื่อสาธิตกฎเหล่านี้ โดยไดเรกทอรีของเครต ซึ่งมีชื่อว่า backyard เช่นกัน ประกอบด้วยโครงสร้างไฟล์และโฟลเดอร์ดังต่อไปนี้:
backyard
├── Cargo.lock
├── Cargo.toml
└── src
├── garden
│ └── vegetables.rs
├── garden.rs
└── main.rs
ไฟล์รากของเครตในกรณีนี้คือ src/main.rs ซึ่งมีเนื้อหาดังนี้:
use crate::garden::vegetables::Asparagus;
pub mod garden;
fn main() {
let plant = Asparagus {};
println!("I'm growing {plant:?}!");
}
บรรทัด pub mod garden; เป็นการสั่งให้คอมไพเลอร์นำโค้ดที่พบในไฟล์ src/garden.rs มารวมเข้าด้วยกัน ซึ่งไฟล์ดังกล่าวมีเนื้อหาคือ:
pub mod vegetables;
ในไฟล์นี้ คำสั่ง pub mod vegetables; หมายถึงการนำโค้ดในไฟล์ src/garden/vegetables.rs เข้ามารวมด้วยเช่นกัน ซึ่งโค้ดในไฟล์นั้นมีดังนี้:
#[derive(Debug)]
pub struct Asparagus {}
คราวนี้ เราลองมาเจาะลึกรายละเอียดของกฎเกณฑ์เหล่านี้ และดูการนำไปประยุกต์ใช้งานจริงกัน!
การจัดกลุ่มโค้ดที่เกี่ยวข้องไว้ในมอดูล
มอดูล (Modules) ช่วยให้เราสามารถจัดระเบียบโครงสร้างโค้ดภายในเครตให้อ่านเข้าใจง่ายและนำกลับมาใช้ซ้ำได้อย่างสะดวก นอกจากนี้ มอดูลยังช่วยให้เราควบคุม_ระดับการเข้าถึง (privacy)_ ของไอเทมต่างๆ ได้ เนื่องจากโค้ดทั้งหมดที่อยู่ภายในมอดูลจะมีสถานะเป็นแบบส่วนตัว (private) โดยปริยาย ซึ่งไอเทมส่วนตัวเหล่านี้ถือเป็นรายละเอียดการทำงานภายในที่ไม่เปิดให้โค้ดภายนอกเรียกใช้งาน แต่เราสามารถเลือกกำหนดให้มอดูลและไอเทมภายในเป็นสาธารณะ (public) ได้ เพื่อเปิดให้โค้ดจากภายนอกสามารถเรียกใช้และพึ่งพาพวกมันได้
ตัวอย่างเช่น เราลองมาเขียนเครตไลบรารีที่จำลองระบบการทำงานของร้านอาหารกัน โดยเราจะนิยามเฉพาะโครงสร้างซิกเนเจอร์ (signatures) ของฟังก์ชันไว้ และปล่อยให้เนื้อในของฟังก์ชันว่างเปล่า เพื่อมุ่งเน้นไปที่การจัดระเบียบโครงสร้างโค้ดเป็นหลัก มากกว่าการลงรายละเอียดการทำงานจริงของร้านอาหาร
ในธุรกิจร้านอาหาร เรามักจะแบ่งพื้นที่ออกเป็นสองส่วนหลักคือ หน้าร้าน (front of house) และหลังร้าน (back of house) ส่วน หน้าร้าน (Front of house) คือบริเวณที่ลูกค้าอยู่ ครอบคลุมถึงจุดที่พนักงานต้อนรับพาไปนั่งโต๊ะ, พนักงานเสิร์ฟรับออร์เดอร์และคิดเงิน ตลอดจนบาร์เทนเดอร์ชงเครื่องดื่ม ส่วน หลังร้าน (Back of house) คือบริเวณที่เชฟและกุ๊กปรุงอาหารอยู่ในครัว, พนักงานล้างจานทำความสะอาด และผู้จัดการดูแลงานเอกสารธุรการ
ในการวางโครงสร้างเครตตามแนวคิดนี้ เราสามารถจัดฟังก์ชันต่างๆ แยกเป็นมอดูลที่ซ้อนกันอยู่ได้ เริ่มต้นด้วยการสร้างไลบรารีใหม่ชื่อ restaurant โดยสั่งรันคำสั่ง cargo new restaurant --lib จากนั้นให้ใส่โค้ดในลิสติ้ง 7-1 ลงในไฟล์ src/lib.rs เพื่อนิยามมอดูลและซิกเนเจอร์ของฟังก์ชันต่างๆ ซึ่งโค้ดชุดนี้จะแทนส่วนการทำงานของหน้าร้าน
mod front_of_house {
mod hosting {
fn add_to_waitlist() {}
fn seat_at_table() {}
}
mod serving {
fn take_order() {}
fn serve_order() {}
fn take_payment() {}
}
}
เรานิยามมอดูลด้วยคำสงวน mod ตามด้วยชื่อของมอดูล (ในกรณีนี้คือ front_of_house) ส่วนเนื้อหาของมอดูลจะอยู่ภายในเครื่องหมายปีกกา ภายในมอดูลเราสามารถวางมอดูลอื่นซ้อนไว้ได้ ดังในกรณีนี้ที่มีมอดูล hosting และ serving นอกจากนี้ ภายในมอดูลยังสามารถบรรจุนิยามของไอเทมอื่นๆ ได้อีกด้วย เช่น struct, enum, ค่าคงที่ (constant), เทรต (trait) และฟังก์ชันดังที่เห็นในลิสติ้ง 7-1
การใช้มอดูลช่วยให้เราสามารถจัดกลุ่มนิยามที่เกี่ยวข้องกันเข้าไว้ด้วยกัน และตั้งชื่อที่สื่อความหมายถึงความเชื่อมโยงนั้นได้อย่างชัดเจน นักพัฒนาคนอื่นๆ ที่นำโค้ดนี้ไปใช้จะสามารถทำความเข้าใจและไล่ดูโค้ดตามหมวดหมู่ได้สะดวกขึ้น แทนที่จะต้องกวาดสายตาอ่านนิยามทั้งหมด ทำให้ค้นหาสิ่งที่ต้องการได้รวดเร็ว และผู้ที่จะเพิ่มความสามารถใหม่ๆ เข้ามาในโค้ดชุดนี้ ก็จะทราบได้ทันทีว่าควรวางโค้ดไว้ที่จุดใดเพื่อให้โปรแกรมยังคงเป็นระเบียบเรียบร้อย
ก่อนหน้านี้ เราได้เกริ่นไว้ว่า src/main.rs และ src/lib.rs เรียกว่า รากของเครต (crate roots) เหตุผลที่เรียกเช่นนี้ก็เพราะว่า เนื้อหาของไฟล์ใดไฟล์หนึ่งในสองไฟล์นี้จะรวมกันเป็นมอดูลชื่อ crate ซึ่งทำหน้าที่เป็นรากฐานของโครงสร้างมอดูลทั้งหมดในเครต เรียกว่า แผนผังมอดูล (module tree)
ลิสติ้ง 7-2 แสดงแผนผังมอดูลสำหรับโครงสร้างในลิสติ้ง 7-1
crate
└── front_of_house
├── hosting
│ ├── add_to_waitlist
│ └── seat_at_table
└── serving
├── take_order
├── serve_order
└── take_payment
แผนผังนี้แสดงให้เห็นว่ามอดูลบางตัวซ้อนอยู่ภายในมอดูลอื่นอย่างไร ตัวอย่างเช่น hosting ซ้อนอยู่ภายใน front_of_house และยังแสดงว่ามอดูลบางตัวเป็น_มอดูลระดับเดียวกันหรือพี่น้อง_ (siblings) ซึ่งหมายถึงมอดูลที่นิยามอยู่ภายในมอดูลแม่เดียวกัน โดย hosting และ serving ถือเป็นมอดูลระดับเดียวกันที่นิยามไว้ภายใน front_of_house หากมอดูล A ซ้อนอยู่ภายในมอดูล B เราจะเรียกว่ามอดูล A เป็น_มอดูลลูก_ (child) ของมอดูล B และมอดูล B เป็น_มอดูลแม่_ (parent) ของมอดูล A สังเกตได้ว่าแผนผังมอดูลทั้งหมดจะมีจุดเริ่มต้นหรือรากฐานอยู่ภายใต้มอดูลโดยปริยายที่มีชื่อว่า crate
แผนผังมอดูลนี้อาจทำให้คุณนึกถึงโครงสร้างโฟลเดอร์หรือไดเรกทอรีในระบบไฟล์บนคอมพิวเตอร์ ซึ่งเป็นการเปรียบเทียบที่เห็นภาพได้อย่างชัดเจนทีเดียว! เช่นเดียวกับไดเรกทอรีในระบบไฟล์ เราใช้มอดูลเพื่อจัดระเบียบโครงสร้างของโค้ด และเช่นเดียวกับไฟล์ในไดเรกทอรี เราจำเป็นต้องมีวิธีการระบุตำแหน่งเพื่อเข้าถึงมอดูลเหล่านั้นด้วย