For-løkker i C#: en enkel guide til gjentakende kode uten hodebry

Mye av programmering handler om å gjøre det samme flere ganger, men på en strukturert og lesbar måte. For-løkker gir deg nettopp dette: kontrollert gjentakelse uten å kopiere den samme koden om og om igjen.

I C# er for-løkker en av de viktigste byggeklossene for alt fra enkle konsollprogrammer til større applikasjoner. Her får du en lettfattelig gjennomgang av hvordan de fungerer, hva som ofte går galt, og konkrete mønstre du kan bruke videre.

Hva er en for-løkke, egentlig?

En for-løkke i C# lar deg kjøre den samme blokken med kode flere ganger, vanligvis med en teller som øker eller minker for hver runde. Du bestemmer start, stopp og hvordan telleren endres.

Den klassiske formen ser slik ut:

Eksempel:

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

Her betyr det: start med i = 0, så lenge i er mindre enn 5, kjør koden inni blokken, og øk i med 1 for hver runde.

De tre delene i en for-løkke

En standard for-løkke i C# har tre deler inne i parentesene: initialisering, betingelse og oppdatering. Forstår du disse, forstår du det meste.

Struktur:

for (initialisering; betingelse; oppdatering)
{
    // kode som gjentas
}

Initialisering

I initialiseringen lager du vanligvis en teller, ofte kalt i, j eller k. Den kjører bare én gang, rett før løkken starter.

Eksempel:int i = 0;betyr at vi starter å telle fra 0. Du kan også starte på andre tall, for eksempel 1 eller 10, alt etter hva du skal gjøre.

Betingelse og oppdatering

Betingelsen bestemmer når løkken skal fortsette. Så lenge betingelsen er sann, kjører løkken en ny runde. Når betingelsen blir usann, stopper den.

Eksempel:i < 5betyr at siste runde kjøres når i er 4. Når i blir 5, er betingelsen usann og løkken stopper.

Oppdateringen er koden som kjøres etter hver runde, ofte for å endre telleren. Det vanligste er å øke med 1:i++, men du kan også øke med mer, eller minke:i += 2elleri–.

Vanlige måter å bruke for-løkker på

For-løkker er spesielt nyttige når du skal gjennom en samling av ting, eller når du skal gjøre en beregning et bestemt antall ganger. Her er noen konkrete mønstre.

Gå gjennom en liste med elementer

Anta at du har en liste med tall og vil skrive ut alle verdiene med indeks:

Eksempel:

var tall = new List<int> { 3, 7, 10 };
for (int i = 0; i < tall.Count; i++)
{
    Console.WriteLine($”Indeks {i}: {tall[i]}”);
}

Her bruker vi telleren i til både å vite hvilken runde vi er på, og til å hente rett element fra listen.

Løkke baklengs

Noen ganger er det tryggere eller mer naturlig å gå baklengs, for eksempel hvis du skal fjerne elementer underveis.

Eksempel:

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

Legg merke til at vi starter på siste indeks og fortsetter så lenge i er større enn eller lik 0.

Tre vanlige feil og hvordan du unngår dem

Selv erfarne utviklere kan gjøre enkle feil i for-løkker. Her er tre klassikere og hva du kan gjøre i stedet.

1. Terreng utenfor lista: indeks utenfor gyldig område

Den vanligste feilen er å gå én for langt, for eksempel slik:

for (int i = 0; i <= tall.Count; i++)

Her vil siste runde prøve å lese tall[tall.Count], som ikke finnes. Riktig er som oftest å bruke < i stedet for <=.

2. Uendelige løkker

En uendelig løkke oppstår når betingelsen aldri blir usann. For eksempel:

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

Her oppdateres aldri i, så i er alltid 0. Løsningen er å sørge for en oppdatering som faktisk endrer betingelsen over tid, enten i for-parentesen eller inni selve blokken.

3. For mye logikk i hodet på løkken

Hvis initialisering, betingelse og oppdatering blir for kompliserte, blir løkken vanskelig å lese. Det gjør feilsøking tyngre.

Et godt grep er å holde for-løkken enkel og flytte ekstra logikk inn i blokken eller i egne metoder. Da ser du raskt hvor mange runder løkken faktisk vil kjøre.

Når bør du velge for-løkke, og når noe annet?

Det finnes flere typer løkker i C#, som while og foreach. Valget handler ofte om hva som gjør koden lettest å lese for neste person, og for deg selv om noen måneder.

For-løkke passer ekstra godt når:

• du trenger en teller eller indeks i selve løkken
• du vet nøyaktig hvor mange ganger løkken skal kjøre
• du skal gå gjennom deler av en liste, for eksempel annenhver verdi

Foreach er ofte enklere når du bare skal lese alle elementene i en samling uten å bry deg om indekser. While passer bedre når du ikke vet på forhånd hvor mange runder som trengs.

Små forbedringer som gjør løkkene ryddigere

To like viktig som å få koden til å virke, er å gjøre den lett å forstå. Her er noen små grep som gir stor effekt over tid.

Gi telleren et navn som gir mening hvis funksjonen er litt mer kompleks, for eksempelindexi stedet for bare i. Bruk mellomrom konsekvent og hold blokken inni løkken kort, helst ikke mer enn noen få linjer.

Hvis du merker at en for-løkke vokser og får mye logikk, kan det være et tegn på at du bør trekke ut noe i en egen metode. Da beholder du løkken som et tydelig overblikk over flyten.

Veien videre: øv med små oppgaver

Den raskeste måten å bli trygg på for-løkker er å lage små kodebiter som du kan teste og endre ofte. Start enkelt og bygg gradvis på.

Forslag til øvelser:

• skriv ut alle tall fra 1 til 100 som er delelige med 3
• summer alle tall i en liste og skriv ut totalen
• lag en løkke som går baklengs og bare skriver ut partall

Test hva som skjer når du endrer startverdien, stoppbetingelsen og oppdateringen. Når du intuitivt vet hva løkken vil gjøre før du kjører koden, har du fått et nyttig verktøy du vil bruke overalt i utviklingsarbeidet.