Learn Rust Coding · บทเรียน

pub และการมองเห็น

ควบคุมการเข้าถึง

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

เป็นส่วนตัวโดยค่าเริ่มต้น

ใน Rust ทุกสิ่งภายในโมดูลจะเป็น ส่วนตัวโดยค่าเริ่มต้น โมดูลอื่นจะมองไม่เห็นสิ่งเหล่านี้ เว้นแต่คุณจะเลือกเปิดเผยด้วย pub

ค่าเริ่มต้นที่ปลอดภัยนี้ช่วยซ่อนรายละเอียดการทำงานภายใน จนกว่าคุณจะตั้งใจเปิดเผยออกมา

ฟังก์ชัน pub

การกำกับฟังก์ชันด้วย pub ทำให้สามารถเรียกใช้ฟังก์ชันนั้นจากภายนอกโมดูลได้ หากไม่มีตัวกำกับนี้ การเรียกใช้จะคอมไพล์ไม่สำเร็จ

mod math {
    pub fn square(x: i32) -> i32 {
        x * x
    }
}

fn main() {
    println!("{}", math::square(5));
}

ตัวช่วยส่วนตัวยังคงถูกซ่อน

คุณสามารถเก็บตัวช่วยภายในให้เป็นส่วนตัว ขณะเดียวกันก็เปิดเผยส่วนติดต่อสาธารณะได้ ฟังก์ชันสาธารณะสามารถเรียกใช้ฟังก์ชันส่วนตัวได้ แต่โค้ดภายนอกจะเรียกใช้ฟังก์ชันนั้นไม่ได้

mod math {
    fn double(x: i32) -> i32 { x * 2 }
    pub fn quadruple(x: i32) -> i32 { double(double(x)) }
}

fn main() {
    println!("{}", math::quadruple(3));
}

โครงสร้าง pub ซ่อนฟิลด์

การทำให้โครงสร้างเป็น pub จะเปิดเผยชนิดข้อมูล แต่ฟิลด์ของโครงสร้างจะยังคงเป็นส่วนตัว เว้นแต่จะกำกับแต่ละฟิลด์ด้วย pub ด้วย

วิธีนี้ช่วยให้คุณควบคุมวิธีสร้างและแก้ไขโครงสร้างได้

mod model {
    pub struct User {
        pub name: String,
        age: u32,
    }
    impl User {
        pub fn new(name: String, age: u32) -> User {
            User { name, age }
        }
        pub fn age(&self) -> u32 { self.age }
    }
}

fn main() {
    let u = model::User::new(String::from("Sam"), 28);
    println!("{} is {}", u.name, u.age());
}

เหตุใดจึงต้องซ่อนฟิลด์

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

อีนัม pub เปิดเผยทุกอย่าง

ต่างจากโครงสร้าง อีนัมที่เป็น pub จะทำให้ตัวเลือกทั้งหมดเป็นสาธารณะโดยอัตโนมัติ ตัวเลือกไม่มีระดับการมองเห็นแยกต่างหาก

mod traffic {
    pub enum Light {
        Red,
        Yellow,
        Green,
    }
}

fn main() {
    let l = traffic::Light::Green;
    let go = matches!(l, traffic::Light::Green);
    println!("go = {}", go);
}

pub(crate): ใช้ได้ทั่วทั้งแครต

pub(crate) ทำให้รายการมองเห็นได้จากทุกที่ภายในแครตเดียวกัน แต่แครตภายนอกที่พึ่งพาแครตของคุณจะมองไม่เห็น

เหมาะอย่างยิ่งสำหรับส่วนติดต่อภายในที่ใช้ร่วมกันระหว่างโมดูล

mod config {
    pub(crate) fn default_port() -> u16 {
        8080
    }
}

fn main() {
    println!("{}", config::default_port());
}

pub(super): ใช้ได้เฉพาะโมดูลแม่

pub(super) เปิดเผยรายการให้เฉพาะโมดูลแม่เท่านั้น ระดับการอนุญาตนี้แคบกว่า pub แบบเต็ม

mod outer {
    pub fn run() {
        inner::helper();
    }
    mod inner {
        pub(super) fn helper() {
            println!("visible to parent only");
        }
    }
}

fn main() {
    outer::run();
}

ส่งออกซ้ำด้วย pub use

pub use ส่งออกรายการซ้ำ ทำให้ผู้เรียกใช้เข้าถึงรายการผ่านพาธที่สั้นหรือสะดวกกว่าได้ วิธีนี้ช่วยออกแบบส่วนติดต่อสาธารณะที่เป็นระเบียบ

mod deep {
    pub mod nested {
        pub fn ping() {
            println!("pong");
        }
    }
    pub use nested::ping;
}

fn main() {
    deep::ping();
}

การออกแบบส่วนติดต่อสาธารณะ

เปิดเผยเฉพาะส่วนที่เล็กที่สุดซึ่งเพียงพอต่อการทำงาน เก็บตัวช่วยไว้เป็นส่วนตัว ซ่อนฟิลด์ของโครงสร้างไว้หลังเมธอด และใช้ pub(crate) สำหรับการใช้งานร่วมกันภายใน

ส่วนติดต่อที่กระชับจะพัฒนาต่อได้ง่ายกว่าโดยไม่ทำให้ผู้ใช้เดิมมีปัญหา

สรุประดับการมองเห็น

จากเข้มงวดที่สุดไปหาน้อยที่สุด:

ค่าเริ่มต้น (เป็นส่วนตัวสำหรับโมดูลนั้น)
pub(super) — มองเห็นได้โดยโมดูลแม่
pub(crate) — มองเห็นได้ทั่วทั้งแครต
pub — มองเห็นได้จากทุกที่

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ทดสอบความเข้าใจเรื่องระดับการมองเห็นของคุณ

ทบทวน

คุณได้เรียนรู้วิธีควบคุมการเข้าถึงแล้ว:

รายการต่าง ๆ เป็นส่วนตัวโดยค่าเริ่มต้น ส่วน pub ใช้เปิดเผยรายการเหล่านั้น
โครงสร้างที่เป็น pub จะเก็บฟิลด์เป็นส่วนตัว เว้นแต่จะกำกับแต่ละฟิลด์ด้วย pub
อีนัมที่เป็น pub จะเปิดเผยตัวเลือกทั้งหมด
pub(crate) และ pub(super) ช่วยควบคุมการเข้าถึงได้ละเอียดขึ้น
pub use ส่งออกรายการซ้ำเพื่อสร้างส่วนติดต่อที่เป็นระเบียบ

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

บทเรียน “pub และการมองเห็น” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “pub และการมองเห็น”

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

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

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

บทเรียน “pub และการมองเห็น” ใช้เวลานานแค่ไหน

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

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

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

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

← กลับไปที่ Learn Rust Coding