Loop kontroller

I den här övningen kommer vi att utforska olika loopkontroller som ger oss mer kontroll över hur loopar beter sig i programmering. Dessa loopkontroller inkluderar break, continue, return, och yield.

TL;DR

Loopkontroller ger oss möjlighet att anpassa loopars beteende. break avbryter en loop, continue hoppar över en iteration, return avslutar en metod, och yield används med iteratorer. Genom att använda dessa loopkontroller kan vi skräddarsy våra loopar efter våra behov och förbättra våra programmeringsfärdigheter.

Vad är Loopkontroller?

Loopkontroller är verktyg som används för att modifiera och anpassa beteendet hos loopar i programmering. Genom att använda loopkontroller kan vi avbryta en loop innan den är klar, hoppa över vissa iterationer eller till och med avsluta en hel metod eller iterator.

Break - Avbryt en Loop

break används för att avbryta en loop innan den har gått igenom alla sina iterationer. Detta kan vara användbart när vi vill avsluta en loop baserat på ett visst villkor.

int max = 5;
for(int i = 0; i < 10; i++)
{
    if(i >= max)
    {
        break;
    }
    Console.WriteLine(i);
}

Resultatet av koden ovan kommer att vara:

0
1
2
3
4

I detta exempel använder vi break för att avsluta loopen när variabeln i når värdet som är lika med eller större än max.

Continue - Hoppa över en Iteration

continue används för att hoppa över en iteration i en loop. Detta innebär att alla kodrader efter continue för den aktuella iterationen kommer att ignoreras, och loopen går vidare till nästa iteration.

int mod = 3;
for(int i = 0; i < 10; i++)
{
    if(i % mod == 0)
    {
        continue;
    }
    Console.WriteLine(i);
}

Resultatet av koden ovan kommer att vara:

1
2
4
5
7
8

Här använder vi continue för att hoppa över alla tal i loopen som är jämnt delbara med värdet av variabeln mod.

Return - Avsluta en Metod

return används för att avsluta en metod innan den är klar. När return nås avslutas metoden omedelbart, och alla kvarvarande kodblokkar efter return kommer inte att utföras.

public static void Main(string[] args)
{
    int max = 5;
    for(int i = 0; i < 10; i++)
    {
        if(i >= max)
        {
            return;
        }
        Console.WriteLine(i);
    }
}

Resultatet av koden ovan kommer att vara:

0
1
2
3
4

I detta exempel avslutas hela Main-metoden när return-uttrycket körs.

Yield - Iterator Control (C-Sharp)

I C-Sharp används yield för att skapa iteratorer och returnera värden ett i taget från en metod. Detta är unikt för C-Sharp och fungerar annorlunda än i Java.

public static IEnumerable<int> GetNumbers(int max)
{
    for (int i = 0; i < 10; i++)
    {
        if (i >= max)
        {
            yield break; // Avsluta iteratorn
        }
        yield return i; // Returnera värdet och fortsätt
    }
}

public static void Main(string[] args)
{
    foreach (int number in GetNumbers(5))
    {
        Console.WriteLine(number);
    }
}

Resultatet av koden ovan kommer att vara:

0
1
2
3
4

Praktiska exempel

Break med nästlade loopar

bool found = false;
for (int i = 0; i < 5 && !found; i++)
{
    for (int j = 0; j < 5; j++)
    {
        if (i * j == 6)
        {
            Console.WriteLine($"Hittade: {i} * {j} = {i * j}");
            found = true;
            break; // Bryter bara den inre loopen
        }
    }
}

Continue med villkor

string[] names = {"Anna", "Bert", "Cecilia", "David"};

foreach (string name in names)
{
    if (name.StartsWith("B") || name.StartsWith("D"))
    {
        continue; // Hoppa över namn som börjar med B eller D
    }
    Console.WriteLine($"Hej {name}!");
}

Goto (bör undvikas)

Även om C-Sharp har goto, bör det undvikas i modern programmering:

// Undvik detta!
for (int i = 0; i < 10; i++)
{
    if (i == 5)
        goto End;
    Console.WriteLine(i);
}

End:
Console.WriteLine("Avslutad med goto");

Best Practices

1. Använd break sparrigt - överväg om en annan loopstruktur vore bättre
2. Continue kan göra kod svårläst - använd istället omvänt villkor när möjligt
3. Return från loopar - tydliggör vad metoden ska returnera
4. Yield är kraftfullt - använd det för lazy evaluation och minneseffektivitet

Termer

Här är en lista över termer som används i artikeln:

Slutsats

Loopkontroller ger oss verktyg för att forma loopar och metoder på ett mer flexibelt sätt. Genom att använda break, continue, return, och yield kan vi förbättra kontrollen och prestandan i våra program. Använd dem klokt för att skapa ren och effektiv kod!