Learn Rust Coding · บทเรียน

คำอธิบายอายุการใช้งาน

การตั้งชื่ออายุการใช้งาน

บทเรียน 2 จาก 413 ขั้นตอน

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

การตั้งชื่ออายุการใช้งาน

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

ตำแหน่งของคำอธิบายประกอบ

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

ไวยากรณ์: fn name<'a>(x: &'a T) -> &'a T

ฟังก์ชัน longest แบบคลาสสิก

ฟังก์ชันที่คืนค่าการอ้างอิงหนึ่งรายการจากสองรายการต้องมีคำอธิบายประกอบ 'a ระบุว่าผลลัพธ์มีอายุเท่ากับอินพุตที่มีอายุสั้นกว่า

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

fn main() {
    let a = String::from("long string");
    let b = String::from("short");
    println!("{}", longest(&a, &b));
}

ความหมายของ 'a ในที่นี้

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

เหตุผลที่จำเป็นต้องมี

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

อายุการใช้งานที่แตกต่างกัน

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

fn first<'a, 'b>(x: &'a str, _y: &'b str) -> &'a str {
    x
}

fn main() {
    let a = String::from("keep me");
    let b = String::from("ignore");
    println!("{}", first(&a, &b));
}

อายุการใช้งานไม่ได้ยืดอายุข้อมูล

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

การเรียกใช้ที่ถูกต้อง

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

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

fn main() {
    let a = String::from("abcdef");
    let result;
    {
        let b = String::from("xy");
        result = longest(&a, &b);
        println!("chosen: {}", result);
    }
}

อายุการใช้งานร่วมกับเจเนอริก

พารามิเตอร์อายุการใช้งานและพารามิเตอร์ชนิดสามารถปรากฏร่วมกันได้ โดยจะแสดงอายุการใช้งานก่อนภายในเครื่องหมายมุม

use std::fmt::Display;

fn announce<'a, T: Display>(text: &'a str, value: T) -> &'a str {
    println!("value is {}", value);
    text
}

fn main() {
    let msg = String::from("hello");
    println!("{}", announce(&msg, 42));
}

อายุการใช้งาน 'static

'static คืออายุการใช้งานพิเศษที่หมายความว่าการอ้างอิงสามารถมีชีวิตอยู่ได้ตลอดทั้งโปรแกรม ลิเทอรัลสตริงมีอายุการใช้งานนี้ เพราะถูกฝังอยู่ในไบนารี

fn motto() -> &'static str {
    "fearless concurrency"
}

fn main() {
    println!("{}", motto());
}

การอ่านคำอธิบายประกอบ

อ่าน &'a str ว่าเป็นการอ้างอิงสตริงที่ใช้ได้ตลอดอายุการใช้งาน 'a เมื่อพารามิเตอร์สองตัวใช้ 'a ร่วมกัน คอมไพเลอร์จะผูกอายุการใช้งานของทั้งคู่กับอายุการใช้งานที่สั้นกว่าในการเรียกใช้แต่ละครั้ง

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

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

ตอบคำถามในบทเรียนแบบโต้ตอบ

สรุปทบทวน

คุณได้เรียนรู้การตั้งชื่ออายุการใช้งาน:

อายุการใช้งานใช้ชื่ออย่าง 'a ซึ่งประกาศไว้ในวงเล็บแหลม
ชื่อที่ใช้ร่วมกันสื่อว่าการอ้างอิงเหล่านั้นมีความสัมพันธ์กัน (เช่น ผลลัพธ์ผูกกับข้อมูลนำเข้า)
คำกำกับใช้อธิบายอายุการใช้งาน แต่ไม่ขยายอายุการใช้งาน
'static หมายถึงใช้ได้ตลอดทั้งโปรแกรม

เริ่มต้นได้ฟรี

เรียนรู้ Rust ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส: 39
บทเรียน: 144

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

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

บทเรียน “คำอธิบายอายุการใช้งาน” ฟรีหรือไม่

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

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

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

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

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

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

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