Vòng lặp for trong C#: cú pháp, đếm ngược, lặp lồng nhau

Vòng lặp (loop) for lặp lại một khối lệnh khi điều kiện còn đúng, với phần chuẩn bị và bước lặp được viết ngay trong phần đầu vòng lặp. Đây là vòng lặp dùng khi bạn đếm: lặp một số lần cố định, hoặc đi qua mọi chỉ số của một mảng.

using System;

class Program
{
    static void Main()
    {
        for (int i = 1; i <= 5; i++)
        {
            Console.WriteLine($"Lap {i} of 5");
        }
    }
}

Đầu ra:

Lap 1 of 5
Lap 2 of 5
Lap 3 of 5
Lap 4 of 5
Lap 5 of 5

Ba phần chạy như thế nào

for (initializer; condition; iterator) thực thi theo một thứ tự cố định:

1. Phần khởi tạo (int i = 1) chạy một lần, trước mọi thứ khác.
2. Điều kiện (i <= 5) được kiểm tra. Nếu sai, vòng lặp kết thúc và thân vòng lặp không chạy thêm lần nào.
3. Thân vòng lặp chạy.
4. Bước lặp (i++) chạy, rồi quay lại bước 2.

Vì điều kiện được kiểm tra trước mỗi lần lặp, một vòng lặp for có thể chạy không lần nào: for (int i = 10; i < 5; i++) không bao giờ vào thân. Vòng lặp ở trên hoạt động giống vòng lặp while này:

int i = 1;
while (i <= 5)
{
    Console.WriteLine($"Lap {i} of 5");
    i++;
}

Hai dạng này khác nhau ở một chi tiết: continue trong thân for vẫn chạy bước lặp, còn trong phiên bản while này nó sẽ nhảy qua i++, nên vòng lặp kiểm tra lại cùng giá trị i và có thể quay mãi không dừng. Một biến khai báo trong phần khởi tạo chỉ tồn tại bên trong vòng lặp. Nếu cần giá trị cuối cùng của nó sau đó, hãy khai báo trước vòng lặp: int i; for (i = 0; ...; i++) { }.

Đếm ngược và bước nhảy

Bước lặp có thể là bất kỳ biểu thức nào. Giảm để đếm ngược, cộng nhiều hơn một để nhảy bước, hoặc nhân để tạo dãy cấp số nhân:

using System;

class Program
{
    static void Main()
    {
        for (int t = 3; t >= 1; t--)
            Console.Write($"{t}... ");
        Console.WriteLine("liftoff");

        for (int minute = 0; minute < 60; minute += 15)
            Console.Write($" {minute:D2}");
        Console.WriteLine();

        for (int size = 1; size <= 1000; size *= 10)
            Console.Write($" {size}");
        Console.WriteLine();
    }
}

Đầu ra:

3... 2... 1... liftoff
 00 15 30 45
 1 10 100 1000

Hãy chắc rằng bước lặp đưa điều kiện dần về sai. for (int i = 0; i < 10; i--) đếm xa dần khỏi 10 và chỉ dừng khi i bị tràn số sau hai tỷ lần lặp.

Duyệt mảng theo chỉ số

Mảng có Length, list có Count, và chỉ số hợp lệ chạy từ 0 đến giá trị đó trừ một. Chỉ số cho bạn những thứ mà foreach không có: biết vị trí, truy cập phần tử kề bên và được ghi ngược vào mảng.

using System;

class Program
{
    static void Main()
    {
        decimal[] prices = { 19.99m, 5.00m, 42.50m, 8.25m };

        for (int i = 0; i < prices.Length; i++)
        {
            prices[i] = prices[i] * 0.9m;          // 10% off, written back
        }

        for (int i = 0; i < prices.Length; i++)
        {
            Console.WriteLine($"#{i + 1}: {prices[i]:F2}");
        }

        for (int i = 1; i < prices.Length; i++)
        {
            string trend = prices[i] > prices[i - 1] ? "up" : "down";
            Console.WriteLine($"item {i} vs item {i - 1}: {trend}");
        }
    }
}

Đầu ra:

#1: 17.99
#2: 4.50
#3: 38.25
#4: 7.43
item 1 vs item 0: down
item 2 vs item 1: up
item 3 vs item 2: down

Vòng lặp cuối bắt đầu từ 1 vì nó so sánh mỗi phần tử với phần tử đứng trước. Trang về mảng trình bày cách tạo, sắp xếp và sao chép mảng.

Nhiều biến lặp

Phần khởi tạo có thể khai báo nhiều biến cùng kiểu, và bước lặp có thể cập nhật nhiều biến, phân tách bằng dấu phẩy. Cách dùng kinh điển là hai chỉ số tiến dần về phía nhau:

using System;

class Program
{
    static void Main()
    {
        char[] word = "racecar".ToCharArray();
        bool palindrome = true;

        for (int left = 0, right = word.Length - 1; left < right; left++, right--)
        {
            if (word[left] != word[right])
            {
                palindrome = false;
                break;
            }
        }

        Console.WriteLine($"racecar is a palindrome: {palindrome}");

        int[] scores = { 3, 8, 1, 9 };
        for (int i = 0, j = scores.Length - 1; i < j; i++, j--)
        {
            int tmp = scores[i];
            scores[i] = scores[j];
            scores[j] = tmp;
        }
        Console.WriteLine(string.Join(", ", scores));
    }
}

Đầu ra:

racecar is a palindrome: True
9, 1, 8, 3

Trong cùng một khai báo, các biến phải cùng kiểu: int left = 0, right = 10 hợp lệ, còn int i = 0, string s = "" thì không.

Vòng lặp lồng nhau

Một vòng lặp nằm trong vòng lặp khác sẽ chạy hết phạm vi của nó cho mỗi lần lặp của vòng ngoài. Bảng và lưới là trường hợp điển hình:

using System;

class Program
{
    static void Main()
    {
        for (int row = 1; row <= 4; row++)
        {
            for (int col = 1; col <= 4; col++)
            {
                Console.Write((row * col).ToString().PadLeft(4));
            }
            Console.WriteLine();
        }
    }
}

Đầu ra:

   1   2   3   4
   2   4   6   8
   3   6   9  12
   4   8  12  16

Thân vòng trong chạy 16 lần (4 × 4). Lồng nhau làm khối lượng công việc tăng rất nhanh: hai vòng lặp lồng nhau, mỗi vòng qua 10.000 phần tử, là 100 triệu lần lặp. Một break trong vòng trong chỉ thoát khỏi vòng trong; trang break và continue chỉ cách thoát khỏi cả hai.

Vòng lặp vô hạn: for(;;)

Cả ba phần của phần đầu vòng lặp đều không bắt buộc. Không có điều kiện, vòng lặp chạy cho đến khi có thứ gì đó bên trong thoát ra:

using System;

class Program
{
    static void Main()
    {
        int balance = 100;
        int month = 0;

        for (;;)
        {
            month++;
            balance -= 30;
            if (balance < 0)
            {
                Console.WriteLine($"Overdrawn in month {month}: {balance}");
                break;
            }
            Console.WriteLine($"Month {month}: {balance} left");
        }
    }
}

Đầu ra:

Month 1: 70 left
Month 2: 40 left
Month 3: 10 left
Overdrawn in month 4: -20

for (;;) và while (true) được biên dịch thành cùng một thứ; hãy chọn cách mà codebase của bạn đang dùng.

Lỗi lệch một đơn vị

Lỗi for phổ biến nhất là điều kiện đi quá một bước:

using System;

class Program
{
    static void Main()
    {
        string[] names = { "Ada", "Grace", "Linus" };

        try
        {
            for (int i = 0; i <= names.Length; i++)     // bug: <= instead of <
            {
                Console.WriteLine(names[i]);
            }
        }
        catch (IndexOutOfRangeException e)
        {
            Console.WriteLine($"{e.GetType().Name} at index {names.Length}");
        }
    }
}

Đầu ra:

Ada
Grace
Linus
IndexOutOfRangeException at index 3

Một mảng 3 phần tử có chỉ số 0, 1 và 2, nên i < names.Length là điều kiện đúng. Lỗi ngược lại là đếm lùi với i > 0, khiến chỉ số 0 không bao giờ được duyệt. Với List<T>, cùng lỗi đó sẽ ném ArgumentOutOfRangeException.

Xóa phần tử khi đang lặp

Xóa khỏi một List<T> trong vòng lặp tiến sẽ dịch mọi phần tử phía sau lùi một vị trí, nên vòng lặp bỏ qua phần tử ngay sau mỗi lần xóa:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var stock = new List<int> { 5, 0, 0, 3, 0, 7 };
        for (int i = 0; i < stock.Count; i++)
        {
            if (stock[i] == 0) stock.RemoveAt(i);
        }
        Console.WriteLine("forward:  " + string.Join(", ", stock));

        stock = new List<int> { 5, 0, 0, 3, 0, 7 };
        for (int i = stock.Count - 1; i >= 0; i--)
        {
            if (stock[i] == 0) stock.RemoveAt(i);
        }
        Console.WriteLine("backward: " + string.Join(", ", stock));
    }
}

Đầu ra:

forward:  5, 0, 3, 7
backward: 5, 3, 7

Vòng lặp tiến còn sót lại một số 0: sau khi xóa chỉ số 1, số 0 thứ hai dịch về chỉ số 1, nhưng i++ đã chuyển sang chỉ số 2. Lặp ngược tránh được lỗi này vì việc xóa chỉ dịch những phần tử bạn đã duyệt qua. Muốn một cách viết trên một dòng, stock.RemoveAll(x => x == 0) làm đúng việc đó. Vòng lặp foreach hoàn toàn không cho xóa; nó ném InvalidOperationException.

Biến đếm số thực

Tránh biến đếm kiểu double khi điều kiện so sánh bằng. 0.1 không có biểu diễn nhị phân chính xác, nên cộng nó mười lần không cho ra đúng 1.0:

for (double x = 0; x != 1.0; x += 0.1)   // never ends: x skips past 1.0
{
}

Thay vào đó, hãy đếm bằng số nguyên và tính giá trị từ nó: for (int i = 0; i <= 10; i++) { double x = i / 10.0; }.

for và foreach

Với mảng, hai vòng lặp được biên dịch thành code gần như giống hệt nhau, nên hãy chọn theo độ dễ đọc, không phải tốc độ.