En for-løkke er en repetisjonssetning som utfører én eller flere programinstruksjoner et gitt antall ganger. Den er spesielt egnet i situasjoner der det er kjent for programmet hvor mange ganger instruksjonen(e) skal gjentas, for eksempel i forbindelse med gjennomløping av data lagret i tabeller.

Faktaboks

Også kjent som

iterasjon, for-iterasjon

Når vi trenger å gjenta én eller flere programinstruksjoner, er det en fordel å legge instruksjonene inn i en løkke, slik at vi kun trenger å skrive dem én gang. Vet vi i tillegg hvor mange ganger instruksjonene skal gjentas, vil en for-løkke være et godt valg. Det er imidlertid alltid mulig å bruke en while-løkke, men en for-løkke har en logisk struktur gjør den «skreddersydd» for situasjoner der programmet ved starten av løkken enten vet hvor mange ganger den skal gjennomløpes eller når den skal avsluttes.

For-løkka består av fire deler og kan beskrive på følgende form i pseudo-kode:

for ( < initialisering >; < betingelse >; < oppdatering > )

< instruksjon >

For-løkkas instruksjon(er) kalles gjerne for løkkekroppen. Dersom denne inneholder mer enn én instruksjon, kan den erstattes av en sammensatt programsetning, det vil si en blokk bestående av flere instruksjoner:

for ( < initialisering >; < betingelse >; < oppdatering > ) {

< løkkekropp bestående av en eller flere instruksjoner >

}

Utførelse

For-løkkas fire deler utføres i følgende rekkefølge:

  1. < initialisering > Her opprettes vanligvis av en heltallsvariabel som samtidig gis en startverdi. Denne første delen av for-løkken utføres kun én gang. Tellevariabelen er en såkalt lokal variabel som kun kan refereres til inne i for-løkka (den vil ikke «eksistere» utenfor).
  2. < betingelse > Testen er en logisk betingelse som avgjør om løkkas instruksjoner skal utføres eller ikke. Testen er gjerne et logisk uttrykk som sjekker om tellevariablene har nådd sin maksimumsverdi (minimumsverdi). Hvis den betingelsen er sann, går programkontrollen videre til løkkekroppen.
  3. < instruksjoner > Instruksjonene, som utgjør løkkekroppen, blir utført.
  4. < oppdatering > Etter at løkkekroppens instruksjoner er utført, skjer oppdateringen, som vanligvis er en fast økning (eller minking) av tellevariabelen i retning av løkkebetingelsen, slik at betingelsen til slutt blir usann og løkka terminerer.

Eksempel

Eksempel på en for-løkke i programmeringsspråket Java.
Bilde viser hvordan en for-løkke kan brukes til å summere tallene i en tabell.
Eksempel på en for-løkke i programmeringsspråket Java.
Lisens: CC BY SA 3.0

Følgende for-løkke, skrevet i programmeringsspråket Java, beregner summen av heltallene 1 + 2 + 3 + ... + 99 + 100.

int sum = 0;

for (int i = 1; i <= 100; i++ ) {

sum += i;

}

I eksemplet vil løkka bli gjennomløpt når tellevariabelen i har verdier lik 1, 2, 3, ..., 99, 100, alt i alt 100 ganger. For hvert løkkegjennomløp vil den nye verdien til tellevariabelen i bli lagt til variabelen sum. Når tellevariabelen til slutt økes til 101, blir løkkebetingelsen usann, og programkontrollen hopper ut av løkka. Verdien 101 vil derfor ikke bli addert til summen.

La oss følge utførelsen skritt for skritt:

  1. Tellevariabelen i opprettes og gis startverdien 1. Dette skjer kun denne ene gangen.
  2. Løkketesten i < 100 evalueres. Første gang dette skjer har i-variabelen verdien 1, og det logiske uttrykket 1 < 100 er følgelig sant.
  3. Løkkekroppen, som består av kun av én setning, utføres, dvs. sum-variabelen øker sin verdi med den verdien i-variabelen har. Første gang dette skjer økes verdien av sum-variabelen fra 0 til 1.
  4. Til slutt, etter at løkkekroppen er utført, utføres oppdateringen i++, som har den virkningen at i-variabelens verdi økes med 1, første gang fra 1 til 2.
  5. Etter oppdateringen evalueres løkkebetingelsen på nytt. Hvis den fremdeles er sann, utføres instruksjonene i løkkekroppen, og deretter oppdateres tellevariabelen nok en gang. Slik fortsetter det helt til løkkebetingelse blir usann og løkka terminerer ved at programkontrollen hopper ut av den.

Evig løkke

Det er viktig at løkkebetingelsen til slutt blir usann slik at løkka terminerer. For å få dette til må oppdateringen av tellevariabelen skje i retning av løkkebetingelsen, det vil si for hver gjennomgang av løkka må tellevariabelens verdi gradvis nærme seg den verdien som gjør løkketesten usann. Hvis ikke dette skjer, blir resultatet en såkalt «evig løkke» som går og går. Dette gir en opplevelse av at programmet «henger seg opp» fordi programkontrollen ikke forlater løkka, med mindre vi avbryter programmet.

Løkker inni løkker

Det er ingen begrensninger på hva slags instruksjoner løkkekroppen kan inneholde. Den kan, i tillegg til enkeltinstruksjoner, bestå av nye løkker og/eller valgsetninger. Kort sagt kan ulike programsetninger kombineres som man vil, og på den måten lage forskjellige algoritmer. Nestes programsetninger inni hverandre, bør det sørges for at nestingsdybden ikke blir større enn strengt tatt nødvendig, da logiske feil har en tendens til å følge i kjølevannet av økt kodekompleksitet.

Les mer i Store norske leksikon

Kommentarer

Kommentarer til artikkelen blir synlig for alle. Ikke skriv inn sensitive opplysninger, for eksempel helseopplysninger. Fagansvarlig eller redaktør svarer når de kan. Det kan ta tid før du får svar.

Du må være logget inn for å kommentere.

eller registrer deg