Learn Rust Coding · บทเรียน

อายุการใช้งานในสตรักต์

ฟิลด์ที่ยืมมา

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

โครงสร้างสามารถยืมข้อมูลได้

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

สิ่งนี้รับประกันว่าโครงสร้างจะไม่คงอยู่เกินกว่าข้อมูลที่ยืมมา

การประกาศอายุการใช้งานบนโครงสร้าง

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

struct Excerpt<'a> {
    text: &'a str,
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first = novel.split('.').next().unwrap();
    let e = Excerpt { text: first };
    println!("{}", e.text);
}

ข้อจำกัดที่เพิ่มเข้ามา

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

เมธอดบนโครงสร้างที่ยืมข้อมูล

เมธอดบนโครงสร้างประเภทนี้จะมีอายุการใช้งานอยู่ในส่วนหัว impl ด้วย โดยทั่วไปคุณสามารถละอายุการใช้งานในตัวเมธอดได้ เนื่องจากการละเว้นอายุการใช้งาน (ซึ่งจะกล่าวถึงในบทเรียนถัดไป)

struct Excerpt<'a> { text: &'a str }

impl<'a> Excerpt<'a> {
    fn announce(&self) -> &str {
        println!("Attention!");
        self.text
    }
}

fn main() {
    let s = String::from("hello world");
    let e = Excerpt { text: &s };
    println!("{}", e.announce());
}

ทำไมไม่เป็นเจ้าของข้อมูลไปเลย

การเป็นเจ้าของข้อมูล (โดยใช้ String) เรียบง่ายกว่าและมักเป็นตัวเลือกที่แนะนำ การยืมข้อมูลช่วยหลีกเลี่ยงการคัดลอกข้อมูลขนาดใหญ่ และมีประโยชน์สำหรับตัวแยกวิเคราะห์กับมุมมองที่อ่านข้อมูลจากบัฟเฟอร์ที่มีอยู่แล้ว

ควรใช้อายุการใช้งานในโครงสร้างเมื่อการยืมข้อมูลให้ประโยชน์อย่างชัดเจนเท่านั้น

ตัวอย่างมุมมองของตัวแยกวิเคราะห์

โครงสร้างที่เก็บสไลซ์ซึ่งชี้เข้าไปในสตริงต้นฉบับเป็นการใช้งานแบบคลาสสิก โครงสร้างนี้อ่านบัฟเฟอร์ต้นฉบับโดยไม่ต้องคัดลอก

struct Token<'a> {
    word: &'a str,
}

fn main() {
    let line = String::from("let x = 5");
    let tokens: Vec<Token> = line.split_whitespace().map(|w| Token { word: w }).collect();
    for t in &tokens {
        println!("token: {}", t.word);
    }
}

ฟิลด์การอ้างอิงหลายฟิลด์

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

struct Pair<'a> {
    left: &'a str,
    right: &'a str,
}

fn main() {
    let a = String::from("foo");
    let b = String::from("bar");
    let p = Pair { left: &a, right: &b };
    println!("{} {}", p.left, p.right);
}

ข้อผิดพลาดจากโครงสร้างที่มีการอ้างอิงค้าง

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

การคืนค่าโครงสร้างที่ยืมข้อมูล

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

struct Wrap<'a> { inner: &'a str }

fn wrap<'a>(s: &'a str) -> Wrap<'a> {
    Wrap { inner: s }
}

fn main() {
    let text = String::from("wrapped");
    let w = wrap(&text);
    println!("{}", w.inner);
}

ข้อแลกเปลี่ยนระหว่างการเป็นเจ้าของกับการยืม

แนวทางอย่างรวดเร็ว:

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

แบบจำลองในใจ

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

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

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

สรุปทบทวน

คุณได้เรียนรู้อายุการใช้งานในโครงสร้าง:

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

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

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

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

บทเรียน “อายุการใช้งานในสตรักต์” ใช้เวลานานแค่ไหน

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

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

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

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

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