לולאת for ב-C#: תחביר, ספירה לאחור, לולאות מקוננות ומלכודות

לולאת for חוזרת על בלוק כל עוד תנאי מתקיים, כשההכנה והקידום כתובים בכותרת הלולאה. זו הלולאה לשימוש כשסופרים: מספר קבוע של חזרות, או כל אינדקס של מערך.

using System;

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

פלט:

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

איך שלושת החלקים רצים

for (initializer; condition; iterator) מתבצעת בסדר קבוע:

1. האתחול (int i = 1) רץ פעם אחת, לפני כל דבר אחר.
2. התנאי (i <= 5) נבדק. אם הוא שקרי, הלולאה מסתיימת והגוף לא רץ יותר.
3. הגוף רץ.
4. הקידום (i++) רץ, ואז השליטה חוזרת לשלב 2.

מכיוון שהתנאי נבדק לפני כל איטרציה, לולאת for יכולה לרוץ אפס פעמים: for (int i = 10; i < 5; i++) אף פעם לא נכנסת לגוף שלה. הלולאה שלמעלה מתנהגת כמו לולאת ה-while הזו:

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

שתי הצורות שונות בפרט אחד: continue בתוך גוף של for עדיין מריץ את הקידום, בעוד שבגרסת ה-while הזו הוא היה מדלג על i++, ולכן הלולאה הייתה בודקת שוב את אותו i ועלולה להסתובב לנצח. משתנה שמוצהר באתחול קיים רק בתוך הלולאה. אם צריך את הערך הסופי שלו אחר כך, הצהירו עליו לפני הלולאה: int i; for (i = 0; ...; i++) { }.

ספירה לאחור וקפיצות

הקידום יכול להיות כל ביטוי. הורידו כדי לספור לאחור, הוסיפו יותר מאחד כדי לקפוץ, או הכפילו בשביל סדרה הנדסית:

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();
    }
}

פלט:

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

ודאו שהקידום מתקדם לכיוון שבו התנאי יהפוך לשקרי. for (int i = 0; i < 10; i--) סופרת הרחק מ-10 ועוצרת רק כש-i מתגלגל מסביב אחרי שני מיליארד איטרציות.

מעבר על מערך לפי אינדקס

למערכים יש Length, לרשימות יש Count, והאינדקסים התקינים רצים מ-0 עד אחד פחות מזה. האינדקס נותן משהו ש-foreach לא נותנת: גישה למיקום, לשכנים, והאפשרות לכתוב בחזרה.

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}");
        }
    }
}

פלט:

#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

הלולאה האחרונה מתחילה ב-1 כי היא משווה כל איבר לזה שלפניו. העמוד על מערכים מכסה יצירה, מיון והעתקה של מערכים עצמם.

כמה משתני לולאה

האתחול יכול להצהיר על כמה משתנים מאותו טיפוס, והקידום יכול לעדכן כמה מהם, מופרדים בפסיקים. השימוש הקלאסי הוא שני אינדקסים שהולכים זה לקראת זה:

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));
    }
}

פלט:

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

בהצהרה אחת שני המשתנים חייבים להיות מאותו טיפוס: int left = 0, right = 10 עובד, int i = 0, string s = "" לא.

לולאות מקוננות

לולאה בתוך לולאה מריצה את כל הטווח שלה פעם אחת בכל איטרציה של הלולאה החיצונית. טבלאות ורשתות הן המקרה הטיפוסי:

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();
        }
    }
}

פלט:

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

הגוף הפנימי רץ 16 פעמים (4 × 4). קינון מכפיל את העבודה מהר: שתי לולאות מקוננות על 10,000 פריטים כל אחת הן 100 מיליון איטרציות. break בלולאה הפנימית יוצא רק מהלולאה הפנימית; העמוד על break ו-continue מראה איך לצאת משתיהן.

לולאות אינסופיות: for(;;)

כל שלושת החלקים של הכותרת אופציונליים. בלי תנאי, הלולאה רצה עד שמשהו בתוכה יוצא:

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");
        }
    }
}

פלט:

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

for (;;) ו-while (true) מתקמפלות לאותו דבר; בחרו את מה שבסיס הקוד שלכם משתמש בו.

טעויות באחד (off-by-one)

הבאג הנפוץ ביותר ב-for הוא תנאי שהולך צעד אחד רחוק מדי:

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}");
        }
    }
}

פלט:

Ada
Grace
Linus
IndexOutOfRangeException at index 3

למערך של 3 איברים יש אינדקסים 0, 1 ו-2, ולכן i < names.Length הוא התנאי הנכון. הבאג ההפוך הוא ספירה לאחור עם i > 0, שאף פעם לא מבקרת באינדקס 0. ב-List<T>, אותה טעות זורקת במקום זאת ArgumentOutOfRangeException.

מחיקת פריטים תוך כדי לולאה

מחיקה מ-List<T> בתוך לולאה קדימה מזיזה כל איבר שאחריה מקום אחד אחורה, ולכן הלולאה מדלגת על האיבר שבא מיד אחרי כל מחיקה:

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));
    }
}

פלט:

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

הלולאה קדימה השאירה 0 מאחור: אחרי מחיקת אינדקס 1, האפס השני זז לאינדקס 1, אבל i++ כבר התקדם לאינדקס 2. מעבר מהסוף להתחלה מונע את זה כי מחיקות מזיזות רק איברים שכבר ביקרתם בהם. כחלופה בשורה אחת, stock.RemoveAll(x => x == 0) עושה את אותו הדבר. לולאת foreach לא מאפשרת מחיקה בכלל; היא זורקת InvalidOperationException.

מונים של נקודה צפה

הימנעו ממוני לולאה מטיפוס double שנבדקים בשוויון. ל-0.1 אין ייצוג בינארי מדויק, ולכן חיבור שלו עשר פעמים לא נותן בדיוק 1.0:

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

ספרו עם מספר שלם וחשבו ממנו את הערך: for (int i = 0; i <= 10; i++) { double x = i / 10.0; }.

for מול foreach

על מערכים, שתי הלולאות מתקמפלות למעשה לאותו קוד, אז בחרו לפי מה שקריא יותר ולא לפי מהירות.