Learn Rust Coding · บทเรียน

เหตุใดจึงต้องมีอายุการใช้งาน

ป้องกันการอ้างอิงที่ชี้ไปยังหน่วยความจำที่ถูกคืนพื้นที่

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

การอ้างอิงต้องยังใช้งานได้

การอ้างอิงยืมข้อมูลที่ไม่ได้เป็นเจ้าของ Rust ต้องรับประกันว่าข้อมูลจะมีอายุอย่างน้อยเท่ากับการอ้างอิง อายุการใช้งานคือวิธีที่คอมไพเลอร์ใช้ติดตามเรื่องนี้

หน้าที่ของมันคือป้องกัน การอ้างอิงที่ลอยค้าง

การอ้างอิงที่ลอยค้างคืออะไร

การอ้างอิงที่ลอยค้างชี้ไปยังหน่วยความจำที่ถูกคืนแล้ว ในภาษาที่ไม่มีการตรวจสอบ การใช้งานสิ่งนี้อาจทำให้โปรแกรมล่มหรือเกิดข้อบกพร่องด้านความปลอดภัย Rust จะปฏิเสธไม่ให้คอมไพล์โค้ดดังกล่าว

ตัวตรวจสอบการยืมขณะทำงาน

โค้ดนี้จะสร้างการอ้างอิงไปยังค่าที่หมดขอบเขตการใช้งาน Rust จะปฏิเสธโค้ดนี้ขณะคอมไพล์ อายุการใช้งานคือกฎที่ Rust ใช้ตัดสิน

fn main() {
    let r;
    {
        let x = 5;
        r = &x;
        println!("inside: {}", r);
    }
    // using r here would be a dangling reference
    println!("done");
}

ขอบเขตการใช้งานกำหนดอายุการใช้งาน

อายุการใช้งานของค่าคือช่วงเวลาที่ค่านั้นยังใช้งานได้ ซึ่งโดยทั่วไปคือขอบเขตการใช้งานของค่านั้น การอ้างอิงต้องมีอายุไม่ยาวนานกว่าค่าที่อ้างถึง

ในที่นี้ทั้ง x และการอ้างอิงอยู่ในขอบเขตเดียวกัน จึงใช้งานได้

fn main() {
    let x = 5;
    let r = &x;
    println!("x is {}, r is {}", x, r);
}

การคืนค่าการอ้างอิง

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

การคืนค่าการยืมจากอินพุต

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

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();
    for (i, &b) in bytes.iter().enumerate() {
        if b == b' ' {
            return &s[..i];
        }
    }
    s
}

fn main() {
    let sentence = String::from("hello world");
    println!("{}", first_word(&sentence));
}

อายุการใช้งานมีเฉพาะขณะคอมไพล์

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

ความเป็นเจ้าของและอายุการใช้งานร่วมกัน

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

fn main() {
    let data = vec![1, 2, 3];
    let view = &data[0..2];
    println!("{:?}", view);
    // data still owns the vector; view just borrows part of it
    println!("{:?}", data);
}

เหตุผลที่ชื่อปรากฏในลายเซ็น

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

บทเรียนถัดไปจะครอบคลุมไวยากรณ์นี้

ประโยชน์ที่ได้รับ

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

แบบจำลองทางความคิด

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

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

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

สรุปทบทวน

คุณได้เรียนรู้เหตุผลที่มีอายุการใช้งาน:

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

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

บทเรียน “เหตุใดจึงต้องมีอายุการใช้งาน” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “เหตุใดจึงต้องมีอายุการใช้งาน” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ 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 ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “เหตุใดจึงต้องมีอายุการใช้งาน” ใช้เวลานานแค่ไหน

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

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

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

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

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