Learn Rust Coding · บทเรียน

กฎการละคำอธิบาย

กรณีที่อนุมานอายุการใช้งานได้

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

อายุการใช้งานที่คุณไม่ต้องเขียน

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

การละเว้นเป็นเพียงทางลัด

การละเว้นไม่ได้ลบอายุการใช้งานออก คอมไพเลอร์ยังคงเติมอายุการใช้งานให้เบื้องหลังโดยใช้กฎที่กำหนดไว้อย่างแน่นอน เมื่อกฎเหล่านี้ครอบคลุมกรณีของคุณ คุณก็สามารถละคำกำกับได้

ฟังก์ชันที่ละเว้นอายุการใช้งาน

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

fn first_word(s: &str) -> &str {
    s.split(' ').next().unwrap_or("")
}

fn main() {
    let phrase = String::from("rust is fun");
    println!("{}", first_word(&phrase));
}

กฎข้อที่ 1: ข้อมูลนำเข้าแต่ละรายการมีอายุการใช้งานของตนเอง

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

กฎข้อที่ 2: ข้อมูลนำเข้าหนึ่งรายการ ข้อมูลส่งออกหนึ่งรายการ

กฎข้อที่สองคือ หากมีอายุการใช้งานของข้อมูลนำเข้าอยู่เพียงหนึ่งรายการ ระบบจะกำหนดอายุการใช้งานนั้นให้กับอายุการใช้งานของข้อมูลส่งออกทั้งหมด กฎนี้ครอบคลุมฟังก์ชันอย่าง first_word ซึ่งรับและคืนค่าการอ้างอิงหนึ่งรายการ

fn trim_start(s: &str) -> &str {
    s.trim_start()
}

fn main() {
    println!("[{}]", trim_start("   hi"));
}

กฎข้อที่ 3: เมธอดและ &self

กฎข้อที่สามคือ หากเมธอดมี &self หรือ &mut self ระบบจะกำหนดอายุการใช้งานของ self ให้กับอายุการใช้งานของข้อมูลส่งออกทั้งหมด ด้วยเหตุนี้เมธอดจึงแทบไม่ต้องใช้คำกำกับ

struct Holder { value: String }

impl Holder {
    fn get(&self) -> &str {
        &self.value
    }
}

fn main() {
    let h = Holder { value: String::from("stored") };
    println!("{}", h.get());
}

เมื่อการละเว้นใช้ไม่ได้

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

ฟังก์ชัน longest อีกครั้ง

มีข้อมูลนำเข้าที่เป็นการอ้างอิงสองรายการและข้อมูลส่งออกที่เป็นการอ้างอิงหนึ่งรายการ กฎข้อที่ 2 จึงใช้ไม่ได้ (เพราะมีข้อมูลนำเข้ามากกว่าหนึ่งรายการ) และไม่มี self ดังนั้นคุณต้องระบุอายุการใช้งาน

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

fn main() {
    println!("{}", longest("abcd", "ab"));
}

ข้อมูลนำเข้าหลายรายการ ข้อมูลส่งออกจาก self

เมธอดที่มีพารามิเตอร์หลายตัวก็ยังได้รับอายุการใช้งานของข้อมูลส่งออกจาก self ตามกฎข้อที่ 3 แม้ว่าจะมีพารามิเตอร์การอ้างอิงอื่นอยู่ด้วย

struct Doc { body: String }

impl Doc {
    fn announce(&self, _note: &str) -> &str {
        &self.body
    }
}

fn main() {
    let d = Doc { body: String::from("content") };
    println!("{}", d.announce("ping"));
}

เหตุผลที่มีกฎเหล่านี้

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

รายการตรวจสอบอย่างรวดเร็ว

หากต้องการตัดสินว่าการละเว้นใช้ได้หรือไม่ ให้ถามว่า:

มีการอ้างอิงข้อมูลนำเข้าเพียงหนึ่งรายการหรือไม่ ข้อมูลส่งออกจะยืมมาจากรายการนั้น
มี &self หรือไม่ ข้อมูลส่งออกจะยืมมาจาก self
หากไม่ใช่ทั้งสองกรณี ให้ระบุอายุการใช้งานอย่างชัดเจน

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

ทดสอบความเข้าใจเกี่ยวกับกฎการละเว้นอายุการใช้งาน

สรุปทบทวน

คุณได้เรียนรู้ว่าเมื่อใดระบบจะอนุมานอายุการใช้งาน:

กฎข้อที่ 1: การอ้างอิงข้อมูลนำเข้าแต่ละรายการจะมีอายุการใช้งานของตนเอง
กฎข้อที่ 2: อายุการใช้งานของข้อมูลนำเข้าหนึ่งรายการจะถูกจับคู่กับข้อมูลส่งออกทั้งหมด
กฎข้อที่ 3: &self เป็นผู้กำหนดอายุการใช้งานของข้อมูลส่งออกในเมธอด
หากข้อมูลส่งออกยังไม่ชัดเจน คุณต้องระบุอายุการใช้งานอย่างชัดเจน

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

บทเรียน “กฎการละคำอธิบาย” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “กฎการละคำอธิบาย”

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

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

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

บทเรียน “กฎการละคำอธิบาย” ใช้เวลานานแค่ไหน

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

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

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

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

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