Bài viết giới thiệu chi tiết cách sử dụng vòng lặp trong Rust, từ loop vô hạn, while có điều kiện đến vòng lặp for an toàn cùng với iterator và Range. Giải thích cú pháp, ví dụ minh họa, và điểm mạnh giúp lập trình an toàn và hiệu quả.

[Rust] Hướng Dẫn Vòng Lặp Trong Rust: loop, while, for và Range

Trong bài viết thuộc chương 3 này của series tự học Rust, chúng ta sẽ đi sâu vào các khái niệm lập trình cơ bản về vòng lặp trong Rust. Rust hỗ trợ ba loại vòng lặp chính gồm loop, while và for, cùng với kiểu Range để sinh dãy số. Việc hiểu rõ cách sử dụng các vòng lặp giúp code Rust an toàn, hiệu quả và dễ đọc hơn.

Các loại vòng lặp trong Rust

Rust cung cấp ba loại vòng lặp cho các tình huống khác nhau:

loop: vòng lặp vô hạn, chạy liên tục cho đến khi được break dừng lại.
while: thực hiện lặp khi điều kiện đúng, kiểm tra trước mỗi vòng.
for: lặp trên tập hợp (collections) hoặc iterator, an toàn và ngắn gọn hơn while trong nhiều trường hợp.

Ngoài ra, thư viện chuẩn Rust còn hỗ trợ Range để tạo dãy số phục vụ vòng lặp.

1. Vòng lặp `loop`

Từ khóa loop kích hoạt thực thi một đoạn mã liên tục vô hạn. Ví dụ:

fn main() {
    loop {
        println!("6657 up up!");
    }
}

Để thoát khỏi vòng lặp, Rust cho phép dùng break. Đặc biệt, break còn có thể trả về một giá trị, và loop là một biểu thức có thể gán kết quả về biến:

fn main() {
    let mut counter = 0;
    let result = loop {
        counter += 1;
        if counter == 10 {
            break counter * 2;
        }
    };
    println!("The result is: {}", result);
}

Giải thích:

counter tăng dần từ 0 đến 10.
Khi counter == 10, vòng lặp dừng và trả về counter * 2 (20).
Giá trị trả về của loop được gán trực tiếp cho biến result.

Điểm cần lưu ý:

loop là biểu thức và có thể trả về giá trị.
break có thể mang theo dữ liệu trả về.
Khi dùng loop kết hợp gán biến, cần dấu chấm phẩy sau dấu đóng ngoặc } của vòng lặp.

2. Vòng lặp `while`

Vòng lặp while kiểm tra điều kiện trước mỗi vòng:

fn main() {
    let mut countdown = 10;
    println!("Rocket Launch Countdown:");

    while countdown > 0 {
        println!("T-minus {}...", countdown);
        countdown -= 1;
    }

    println!("🚀 Liftoff!");
    println!("Houston, we have a problem.");
}

Kết quả chạy:

Rocket Launch Countdown:
T-minus 10...
T-minus 9...
T-minus 8...
T-minus 7...
T-minus 6...
T-minus 5...
T-minus 4...
T-minus 3...
T-minus 2...
T-minus 1...
🚀 Liftoff!
Houston, we have a problem.

while phù hợp khi bạn muốn lặp có điều kiện rõ ràng nhưng cần chú ý tránh vòng lặp vô tận hoặc lỗi do điều kiện không được cập nhật đúng.

3. Vòng lặp `for` và iterator

for là cách lặp qua từng phần tử của một tập hợp hoặc iterator trong Rust. Nó giúp giảm thiểu lỗi và viết code an toàn hơn so với việc dùng while với chỉ số.

Ví dụ dùng while:

fn main() {
    let numbers = [10, 20, 30, 40, 50];
    let mut index = 0;
    println!("Using while loop:");
    while index < 5 {
        println!("Number at index {}: {}", index, numbers[index]);
        index += 1;
    }
}

Cách dùng while có thể dễ gây lỗi truy cập vượt ngoài chỉ số (panic!).

Giải pháp an toàn hơn dùng for kèm iterator:

fn main() {
    let numbers = [10, 20, 30, 40, 50];
    println!("Using for loop:");
    for (index, number) in numbers.iter().enumerate() {
        println!("Number at index {}: {}", index, number);
    }
}

Giải thích:

.iter() tạo iterator cho mảng, sinh lần lượt các tham chiếu phần tử.
.enumerate() đính kèm số thứ tự (index), bắt đầu từ 0, kết hợp thành tuple (index, &value).
Rust hỗ trợ bóc tách tuple ngay trong vòng lặp for, giúp truy xuất trực tiếp chỉ số và giá trị.

for là cách phổ biến, an toàn và hiệu quả nhất để lặp trên các tập hợp trong Rust.

4. Range và phương thức `rev()`

Rust cung cấp Range như (start..end) để tạo dãy số. .. kiểu Range không bao gồm giá trị cuối, còn ..= bao gồm.

Ví dụ dùng Range và rev() để đếm ngược:

fn main() {
    println!("Rocket Launch Countdown:");
    for countdown in (1..=10).rev() {
        println!("T-minus {}...", countdown);
    }
    println!("🚀 Liftoff!");
    println!("Houston, we have a problem.");
}

(1..=10) tạo Range từ 1 đến 10 bao gồm cả 10.
.rev() đảo ngược dãy số thành 10 xuống 1.

Ưu điểm của Range là cú pháp ngắn gọn, dễ đọc, rất tiện cho các vòng lặp cần giá trị tăng/giảm theo dãy số.

Kết luận

Việc nắm vững các loại vòng lặp trong Rust giúp bạn viết chương trình hiệu quả, tránh lỗi phổ biến và tận dụng các tính năng ngôn ngữ tối ưu:

Dùng loop khi bạn muốn vòng lặp chạy mãi mãi, có thể trả về giá trị qua break.
Dùng while cho vòng lặp dựa trên điều kiện logic cần kiểm tra liên tục.
Dùng for để lặp an toàn trên collections hoặc iterator, tối ưu bằng .iter(), .enumerate().
Dùng Range linh hoạt để sinh dãy số, hỗ trợ đảo chiều với .rev().