For-løkker i C#: slik gjentar du kode uten å miste oversikten

Gjenta den samme kodelogikken flere ganger er noe du gjør hele tiden når du programmerer. For-løkker er et av de viktigste verktøyene for dette i C#, og du møter dem i alt fra enkle konsollprogrammer til webapplikasjoner.

I denne artikkelen går vi gjennom hvordan for-løkker i C# faktisk fungerer, hva de vanligste feilene er, og hvordan du kan skrive lesbar og trygg kode med konkrete eksempler.

Hva er en for-løkke og når bør du bruke den?

En for-løkke lar deg kjøre den samme koden flere ganger, men med en teller som endrer seg for hver runde. Du bruker den typisk når du vet hvor mange ganger noe skal gjentas, eller når du skal gå gjennom en samling med elementer.

Typiske situasjoner der en for-løkke passer godt, er når du vil skrive ut tall fra 1 til 10, gå gjennom en liste med brukere, eller telle hvor mange elementer som matcher en betingelse.

Grunnstrukturen til en for-løkke i C#

La oss starte med den klassiske varianten:

Eksempel:

for (int i = 0; i < 5; i++)
{
    Console.WriteLine(i);
}

En for-løkke har tre deler inni parentesene:

• Start:int i = 0; kjører én gang før løkken starter.
• Betingelse:i < 5; sjekkes før hver runde.
• Oppdatering:i++; kjører etter hver runde.

Løkken fortsetter så lenge betingelsen er sann. Når i ikke lenger oppfyller betingelsen, stopper løkken.

Vanlig feil: av-og-på-med-én (off by one)

En klassisk kilde til feil er å telle én for mye eller én for lite. Dette skjer ofte når du kombinerer <, <=, startverdi og lengder.

Typisk situasjon med tabeller:

int[] tall = { 10, 20, 30, 40 };

// Riktig
for (int i = 0; i < tall.Length; i++)
{
    Console.WriteLine(tall[i]);
}

Hvis du i stedet skriver i <= tall.Length, prøver du å lese ett element utenfor tabellen. Da får du unntaket IndexOutOfRangeException. Hovedregelen er å bruke i < tall.Length når indeksen starter på 0.

For-løkker og lister: når skal du bruke foreach?

Når du går gjennom alle elementene i en liste eller tabell og ikke bryr deg om selve indeksen, er foreach ofte ryddigere:

var navn = new List<string> { "Anna", "Per", "Sara" };

foreach (var n in navn)
{
    Console.WriteLine(n);
}

Likevel er en vanlig for-løkke nyttig når du trenger indeksen, skal hoppe over enkelte elementer, eller vil endre på listen basert på indeksen.

Eksempel der for er nyttig:

for (int i = 0; i < navn.Count; i++)
{
    Console.WriteLine($"{i}: {navn[i]}");
}

Kontroll på flyten: break og continue

Noen ganger vil du avbryte løkken tidligere, eller hoppe over en spesifikk runde. Da kan break og continue være nyttige, men de bør brukes med måte for å bevare lesbarheten.

Avbryte når du har funnet det du leter etter:

int[] tall = { 3, 7, 42, 9 };
int søk = 42;
bool funnet = false;

for (int i = 0; i < tall.Length; i++)
{
    if (tall[i] == søk)
    {
        funnet = true;
        Console.WriteLine($"Fant tallet på indeks {i}");
        break;
    }
}

Hoppe over en runde med continue:

for (int i = 0; i <= 10; i++)
{
    if (i % 2 == 0)
    {
        continue; // hopper over partall
    }

    Console.WriteLine(i);
}

Vurder alltid om en tydeligere betingelse i selve if-setningen kan gjøre koden mer lesbar enn å bruke mange continue.

Hvordan unngå uendelige løkker med for

Det er mindre vanlig å lage uendelige løkker med for enn med while, men det kan skje hvis du glemmer å oppdatere variabelen i riktig retning eller bruker feil betingelse.

Eksempel på feil:

for (int i = 0; i >= 0; i++)
{
    // Dette vil øke i for alltid
    Console.WriteLine(i);
}

Her vil betingelsen alltid være sann så lenge i er et heltall, og løkken stopper ikke. For å unngå slikt bør du kontrollere at:

• Tellerens startverdi gir mening sammen med betingelsen.
• Oppdateringen faktisk beveger seg mot at betingelsen blir usann.

For-løkker med tilpasset steg-størrelse

Du er ikke låst til i++. Du kan øke eller minke med andre steg, eller gå baklengs gjennom en liste.

Gå gjennom annenhver verdi:

for (int i = 0; i <= 10; i += 2)
{
    Console.WriteLine(i);
}

Gå baklengs gjennom en liste:

var navn = new List<string> { "Anna", "Per", "Sara" };

for (int i = navn.Count - 1; i >= 0; i--)
{
    Console.WriteLine(navn[i]);
}

Baklengs løkke er spesielt nyttig når du skal fjerne elementer fra en liste inni løkken. Hvis du fjerner elementer forfra, vil indeksene forskyves og du kan hoppe over elementer ved et uhell.

Lesbarhet: gi tellerne gode navn og hold løkka liten

Selv om det er vanlig å bruke i som tellernavn, er det ofte bedre å velge et mer beskrivende navn i litt større stykker kode, særlig hvis du har nestede løkker.

Eksempel på mer lesbar løkke:

for (int orderIndex = 0; orderIndex < orders.Count; orderIndex++)
{
    var order = orders[orderIndex];
    Console.WriteLine($"Ordre #{orderIndex}: {order.Total}");
}

En annen god vane er å unngå veldig lange løkkekropper. Hvis du gjør mange ting inni løkken, kan du trekke ut deler i egne metoder. Da blir både løkken og koden enklere å teste og feilsøke.

Feilsøking av for-løkker: konkrete tips

Når en for-løkke ikke gjør det du forventer, er det ofte lurt å undersøke hvordan teller og betingelse endrer seg underveis. En enkel måte er å skrive ut verdiene i starten av løkken.

Eksempel på enkel logging:

for (int i = 0; i < tall.Length; i++)
{
    Console.WriteLine($"i={i}, tall[i]={tall[i]}");
    // resten av logikken
}

Du kan også sette et breakpoint i utviklingsverktøyet ditt, kjøre programmet i debug-modus og følge med på variablene steg for steg. Det gir rask forståelse av hvor noe går galt.

Oppsummering: trygg og nyttig bruk av for-løkker

For-løkker i C# er et grunnleggende verktøy for å gjenta logikk på en kontrollert måte. Når du forstår strukturen med start, betingelse og oppdatering, blir det enklere å skrive korrekt og lesbar kode.

Husk å passe særlig på indekser mot .Length eller .Count, tenk gjennom når du egentlig bør bruke foreach, og hold løkkene korte og tydelige. Da får du løkker som er enkle å forstå, endre og feilsøke senere.