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

จัดระเบียบโค้ดด้วยโมดูล

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

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

จัดระเบียบโค้ดด้วยโมดูล

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

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

การประกาศโมดูลแรกของคุณ

คุณประกาศโมดูลโดยใช้คีย์เวิร์ด mod ตามด้วยชื่อโมดูล ซึ่งคล้ายกับการสร้างเนมสเปซย่อยภายในโปรแกรม

มาสร้างโมดูล greetings แบบง่าย ๆ กัน

mod greetings {
    // This is where greeting functions would go
}

fn main() {
    println!("Hello from main!");
}

ทำความเข้าใจความเป็นส่วนตัวของโมดูล

โดยค่าเริ่มต้น ทุกสิ่งภายในโมดูลจะเป็นส่วนตัว นั่นหมายความว่าคุณไม่สามารถเข้าถึงสิ่งเหล่านั้นจากภายนอกโมดูลได้ หากไม่ได้กำหนดให้เป็นสาธารณะอย่างชัดเจน

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

mod greetings {
    fn hello() {
        println!("Hello from the greetings module!");
    }
}

fn main() {
    // Uncomment the line below and try to run!
    // greetings::hello();
    println!("Main function running.");
}

ทำให้รายการเป็นสาธารณะด้วย `pub`

หากต้องการให้รายการ เช่น ฟังก์ชัน โครงสร้าง หรือ enum มองเห็นได้จากภายนอกโมดูล ให้ใช้คีย์เวิร์ด pub

  • pub fn ทำให้ฟังก์ชันเป็นสาธารณะ
  • pub struct ทำให้โครงสร้างเป็นสาธารณะ
  • pub mod ทำให้โมดูลย่อยเป็นสาธารณะ จึงสามารถเข้าถึงเนื้อหาภายในได้

ความเป็นส่วนตัวเป็นส่วนสำคัญของความปลอดภัยและการจัดระเบียบใน Rust

การใช้งาน `pub`

ตอนนี้มาทำให้ฟังก์ชัน hello เป็นสาธารณะโดยใช้ pub กัน วิธีนี้ทำให้ฟังก์ชัน main เรียกใช้ฟังก์ชันดังกล่าวได้โดยไม่เกิดข้อผิดพลาดด้านความเป็นส่วนตัว

เรียกใช้โค้ดนี้เพื่อดูข้อความทักทายจากโมดูลของเรา

mod greetings {
    pub fn hello() {
        println!("Hello from the greetings module!");
    }
}

fn main() {
    greetings::hello();
}

ทำให้เส้นทางสั้นลงด้วย `use`

การพิมพ์เส้นทางแบบเต็ม เช่น greetings::hello() อาจทำให้โค้ดซ้ำซาก คีย์เวิร์ด use ช่วยนำรายการต่าง ๆ เข้ามาอยู่ในขอบเขต ทำให้สามารถอ้างอิงได้ง่ายขึ้น

แนวคิดนี้คล้ายกับ import ใน Python หรือ using ใน C# คุณสามารถนำรายการใดรายการหนึ่งหรือทั้งโมดูลเข้ามาอยู่ในขอบเขตได้

การใช้งาน `use`

นี่คือตัวอย่างการใช้ use เพื่อย่อเส้นทางไปยังฟังก์ชัน hello สังเกตว่าเราไม่จำเป็นต้องใช้คำนำหน้า greetings:: อีกต่อไป

วิธีนี้ทำให้โค้ดสะอาดและอ่านง่ายขึ้น

mod greetings {
    pub fn hello() {
        println!("Hello, module user!");
    }
}

use greetings::hello; // Bring `hello` into scope

fn main() {
    hello(); // Now we can call it directly
}

โมดูลซ้อนกันและเส้นทางสัมพัทธ์

โมดูลสามารถซ้อนกันได้ คุณสามารถกำหนดโมดูลไว้ภายในโมดูลอื่นเพื่อจัดระเบียบให้ละเอียดขึ้น Rust มี super และ self สำหรับการนำทางภายในโมดูลเหล่านี้

  • super หมายถึงโมดูลแม่
  • self หมายถึงโมดูลปัจจุบัน

สิ่งเหล่านี้มีประโยชน์สำหรับใช้เส้นทางสัมพัทธ์ภายในลำดับชั้นของโมดูลที่ซับซ้อน

mod outer {
    pub mod inner {
        pub fn call_me() {
            println!("Called from inner module!");
        }
    }

    pub fn call_inner() {
        // Accessing inner module from parent
        inner::call_me();
    }
}

fn main() {
    outer::call_inner();
    outer::inner::call_me();
}

โมดูลและโครงสร้างไฟล์

สำหรับโมดูลขนาดใหญ่ คุณสามารถแยกโค้ดไปไว้ในไฟล์ต่างหากได้ Rust จะค้นหาคำจำกัดความของโมดูลในตำแหน่งที่กำหนดโดยอัตโนมัติ:

  • สำหรับ mod my_module; ใน src/main.rs Rust จะค้นหา src/my_module.rs หรือ src/my_module/mod.rs
  • วิธีนี้ช่วยให้ไฟล์หลักสะอาด และมอบหมายเนื้อหาไปยังไฟล์ที่เหมาะสม

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

ตรวจสอบการเข้าถึงโมดูล

พิจารณาโค้ด Rust ต่อไปนี้ บรรทัดใดจะคอมไพล์ได้โดยไม่เกิดข้อผิดพลาดด้านความเป็นส่วนตัว

mod calculator {
    fn add(a: i32, b: i32) -> i32 {
        a + b
    }

    pub fn subtract(a: i32, b: i32) -> i32 {
        a - b
    }

    mod advanced {
        pub fn multiply(a: i32, b: i32) -> i32 {
            a * b
        }
    }
}

fn main() {
    // Line A
    // calculator::add(5, 3);

    // Line B
    // calculator::subtract(10, 4);

    // Line C
    // calculator::advanced::multiply(2, 6);

    // Line D
    // calculator::advanced::add(1, 1);
}

โมดูล: จัดระเบียบและควบคุม

ทำได้ดีมาก คุณได้เรียนรู้แล้วว่าระบบโมดูลของ Rust ช่วยจัดโครงสร้างโค้ดของคุณอย่างไร

  • ใช้ mod เพื่อประกาศโมดูลและโมดูลย่อย
  • รายการต่าง ๆ เป็นส่วนตัวโดยค่าเริ่มต้น ใช้ pub เพื่อทำให้เข้าถึงได้
  • use ช่วยย่อเส้นทางยาว ๆ ไปยังรายการต่าง ๆ
  • โมดูลสามารถแบ่งออกเป็นหลายไฟล์สำหรับโปรเจกต์ขนาดใหญ่ได้

โมดูลเป็นพื้นฐานสำคัญสำหรับจัดการความซับซ้อนใน Rust ฝึกฝนต่อไป

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

บทเรียน “จัดระเบียบโค้ดด้วยโมดูล” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “จัดระเบียบโค้ดด้วยโมดูล”

เรียนรู้การใช้ระบบโมดูลของ Rust เพื่อจัดกลุ่มโค้ดอย่างมีเหตุผล จัดการการเข้าถึงแบบส่วนตัว และทำให้โครงการรองรับการขยายตัว คุณปฏิบัติ 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. จัดการสิ่งที่ต้องพึ่งพาด้วย Crates
  3. การจัดการข้อผิดพลาดอย่างแข็งแกร่งด้วย `Result`
← กลับไปที่ Learn Rust Coding