Learn Rust Coding · บทเรียน

อธิบายการอ้างอิงและการยืม

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

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

รีเฟอเรนซ์คืออะไร

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

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

ลองนึกภาพว่าเป็นการมองสิ่งของผ่านหน้าต่าง แทนที่จะเป็นเจ้าของสิ่งของนั้นเอง

รีเฟอเรนซ์แรกของคุณ

เราสร้างรีเฟอเรนซ์โดยใช้ตัวดำเนินการ & ซึ่งจะสร้างตัวชี้ที่ไม่ได้เป็นเจ้าของค่า มาดูการทำงานกัน:

fn print_length(s: &String) {
  println!("The length is: {}", s.len());
}

fn main() {
  let message = String::from("Hello, CoddyKit!");
  print_length(&message); // Pass a reference
  println!("Original message still here: {}", message);
}

ทำความเข้าใจการยืม

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

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

การยืมแบบแก้ไขไม่ได้: เข้าถึงได้เฉพาะการอ่าน

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

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

การยืมแบบแก้ไขไม่ได้ในการใช้งานจริง

ในที่นี้ ฟังก์ชัน calculate_sum รับรีเฟอเรนซ์แบบแก้ไขไม่ได้ไปยังเวกเตอร์ ฟังก์ชันสามารถอ่านสมาชิกต่าง ๆ ได้ แต่ไม่สามารถเพิ่มหรือลบสมาชิกได้

fn calculate_sum(numbers: &Vec<i32>) -> i32 {
  let mut total = 0;
  for num in numbers {
    total += num;
  }
  total
}

fn main() {
  let my_numbers = vec![10, 20, 30, 40];
  let sum = calculate_sum(&my_numbers); // Immutable borrow
  println!("The sum is: {}", sum);
  println!("Original vector: {:?}", my_numbers);
}

การยืมแบบแก้ไขได้: การเปลี่ยนแปลงข้อมูล

บางครั้ง คุณจำเป็นต้องแก้ไขข้อมูลที่คุณยืมมา ในกรณีนี้ ให้ใช้การอ้างอิงแบบแก้ไขได้ ซึ่งเขียนแทนด้วย &mut

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

การแก้ไขข้อมูลด้วย &mut

ฟังก์ชัน add_suffix รับการอ้างอิงแบบแก้ไขได้ไปยัง String จึงสามารถแก้ไข String ต้นฉบับได้โดยตรง

fn add_suffix(text: &mut String) {
  text.push_str(" (modified)");
}

fn main() {
  let mut my_string = String::from("Original text");
  add_suffix(&mut my_string); // Mutable borrow
  println!("Modified string: {}", my_string);
}

กฎทองของการยืม

คอมไพเลอร์ของ Rust บังคับใช้กฎเหล่านี้ในระหว่างการคอมไพล์ เพื่อรับประกันความปลอดภัยของหน่วยความจำ:

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

กฎเหล่านี้ช่วยป้องกันการแข่งขันกันเข้าถึงข้อมูล และทำให้โปรแกรมของคุณปลอดภัยและคาดเดาพฤติกรรมได้

การยืมที่ขัดแย้งกัน

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

ลองเรียกใช้ดู แล้วสังเกตข้อผิดพลาดของคอมไพเลอร์

fn main() {
  let mut my_value = 100;

  let r1 = &my_value; // Immutable reference
  let r2 = &mut my_value; // Mutable reference (problem here!)

  println!("r1: {}", r1);
  // println!("r2: {}", r2); // This line would also cause an error if uncommented
}

ตรวจสอบความเข้าใจของคุณ

พิจารณาข้อมูลโค้ด Rust ต่อไปนี้:

fn process_data(data: &mut Vec<i32>) {
  data.push(4);
}

fn main() {
  let mut numbers = vec![1, 2, 3];
  let first_ref = &numbers[0]; // Line A
  process_data(&mut numbers); // Line B
  println!("First element: {}", first_ref); // Line C
}

บรรทัดใดบ้างที่จะทำให้เกิดข้อผิดพลาดขณะคอมไพล์ เนื่องจากกฎการยืมของ Rust

ทบทวน: การอ้างอิงและการยืม

ทำได้ดีมาก คุณได้เรียนรู้พื้นฐานของการอ้างอิงและการยืมใน Rust แล้ว:

การอ้างอิง (&) ช่วยให้คุณเข้าถึงข้อมูลได้โดยไม่ต้องรับสิทธิ์ความเป็นเจ้าของ
การยืม คือการสร้างการอ้างอิงเพื่อให้ยืมสิทธิ์เข้าถึงข้อมูล
การอ้างอิงแบบอ่านอย่างเดียว (&) ให้สิทธิ์เข้าถึงเพื่ออ่านเท่านั้น
การอ้างอิงแบบแก้ไขได้ (&mut) ให้สิทธิ์เข้าถึงเพื่ออ่านและเขียน
กฎการยืมที่เข้มงวดของ Rust (การอ้างอิงแบบแก้ไขได้หนึ่งรายการ OR การอ้างอิงแบบอ่านอย่างเดียวหลายรายการ) ช่วยป้องกันการแข่งขันกันเข้าถึงข้อมูลและรับประกันความปลอดภัยของหน่วยความจำขณะคอมไพล์

แนวคิดเหล่านี้สำคัญอย่างยิ่งต่อการเขียนโค้ด Rust ที่ปลอดภัยและมีประสิทธิภาพ

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

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

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

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

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

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

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

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

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

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

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

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

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

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