Trong Rust, hệ thống mượn dữ liệu (borrowing) đóng vai trò quan trọng trong việc quản lý bộ nhớ an toàn và hiệu quả. Khi truyền dữ liệu vào hàm, việc sử dụng borrow type (&T hoặc &mut T) giúp tối ưu hiệu suất, tránh sao chép không cần thiết và đảm bảo tính toàn vẹn của dữ liệu.

Arguments

---

Tại Sao Nên Sử Dụng Borrow Type?

1. Tránh sao chép dữ liệu không cần thiết: Nếu truyền tham trị T, dữ liệu có thể bị sao chép, gây lãng phí bộ nhớ.
2. Giữ quyền sở hữu dữ liệu: Khi mượn &T hoặc &mut T, dữ liệu vẫn thuộc về chủ sở hữu ban đầu.
3. Tối ưu hiệu suất: Việc sử dụng tham chiếu giúp tránh các thao tác thừa, cải thiện hiệu suất.
4. Kiểm soát tính bất biến và thay đổi dữ liệu: &T chỉ cho phép đọc, trong khi &mut T cho phép thay đổi nội dung.

---

Ví Dụ

Mượn dữ liệu chỉ đọc &T

fn print_message(message: &str) {
    println!("{}", message);
}

fn main() {
    let greeting = String::from("Xin chào, Rust!");
    print_message(&greeting); // Truyền tham chiếu thay vì chuyển quyền sở hữu
}

🔹 Ở đây, print_message chỉ đọc dữ liệu từ message mà không làm thay đổi nội dung.

Mượn dữ liệu có thể thay đổi &mut T

fn append_exclamation(message: &mut String) {
    message.push_str("!");
}

fn main() {
    let mut greeting = String::from("Xin chào, Rust");
    append_exclamation(&mut greeting);
    println!("{}", greeting); // Kết quả: Xin chào, Rust!
}

🔹 append_exclamation nhận một tham chiếu có thể thay đổi &mut String, cho phép sửa đổi dữ liệu gốc.

---

Luôn ưu tiên mượn kiểu dữ liệu hơn là mượn kiểu sở hữu

Trong thực tế, bạn nên luôn ưu tiên sử dụng kiểu mượn dữ liệu hơn là mượn kiểu sở hữu. Ví dụ, hãy sử dụng &str thay vì &String, &[T] thay vì &Vec<T>, hoặc &T thay vì &Box<T>.

Ví dụ

Không tối ưu: Mượn kiểu sở hữu &String

fn print_length(s: &String) {
    println!("Độ dài: {}", s.len());
}

fn main() {
    let text = String::from("Hello, Rust!");
    print_length(&text);
}

Tối ưu hơn: Mượn kiểu dữ liệu &str

fn print_length(s: &str) {
    println!("Độ dài: {}", s.len());
}

fn main() {
    let text = String::from("Hello, Rust!");
    print_length(&text); // Hoạt động tốt
    print_length("Hello, world!"); // Cũng hoạt động tốt với &str
}

🔹 Sử dụng &str thay vì &String giúp hàm hoạt động linh hoạt hơn với cả String và &str.

Mượn kiểu dữ liệu thay vì &Vec<T>

fn sum_elements(numbers: &[i32]) -> i32 {
    numbers.iter().sum()
}

fn main() {
    let nums = vec![1, 2, 3, 4, 5];
    println!("Tổng: {}", sum_elements(&nums)); // Hoạt động tốt
}

🔹 Dùng &[i32] thay vì &Vec<i32> giúp tổng quát hóa hàm, làm việc với cả mảng &[i32]) và Vec<i32>.

Mượn kiểu dữ liệu thay vì &Box<T>

fn display_value(value: &i32) {
    println!("Giá trị: {}", value);
}

fn main() {
    let boxed_value = Box::new(42);
    display_value(&boxed_value); // Hoạt động tốt
}

🔹 Sử dụng &i32 thay vì &Box<i32> giúp tăng tính linh hoạt.

---

Khi Nào Nên Sử Dụng Borrow Type?

✅ Khi dữ liệu không cần bị thay đổi bên trong hàm, sử dụng &T. ✅ Khi cần thay đổi dữ liệu nhưng không muốn chuyển quyền sở hữu, sử dụng &mut T. ✅ Khi truyền dữ liệu lớn, tránh sao chép bằng cách sử dụng borrowing. ✅ Khi cần tổng quát hóa hàm để làm việc với nhiều kiểu dữ liệu.

---

Kết Luận

Borrowing trong Rust giúp quản lý bộ nhớ an toàn và hiệu quả mà không cần sử dụng bộ thu gom rác (garbage collector). Việc hiểu và sử dụng đúng &T và &mut T giúp tối ưu hóa hiệu suất và tránh các lỗi liên quan đến quyền sở hữu dữ liệu. Hãy luôn ưu tiên sử dụng kiểu mượn dữ liệu (&T) thay vì mượn kiểu sở hữu (&OwnedType).