Lag din første løkke i Norscode

En løkke er hvordan du får koden til å gjenta noe uten å skrive det samme om og om igjen. Det er en av de første tingene som gjør programmering kraftig — og i Norscode leses løkker nesten som vanlig norsk.

mens: gjenta så lenge noe er sant

Den mest grunnleggende løkka er mens. Den gjentar så lenge betingelsen holder:

funksjon start() -> heiltall {
    la i = 0
    mens i < 5 {
        skriv(tekst(i))
        i = i + 1
    }
    returner 0
}

Dette skriver tallene 0 til 4. Legg merke til i = i + 1: uten den ville betingelsen alltid vært sann, og løkka ville aldri stoppet. Glemmer du å bevege deg mot slutten, får du en evig løkke.

Gå gjennom en liste

Ofte vil du gjøre noe med hvert element i en liste. Det kan du gjøre med mens og en teller:

la frukt = ["eple", "pære", "plomme"]
la i = 0
mens i < lengde(frukt) {
    skriv(frukt[i])
    i = i + 1
}

lengde(frukt) gir antall elementer, og frukt[i] henter element nummer i.

for: den enklere måten

Når du bare skal innom hvert element, finnes en kortere form med for:

for f i frukt {
    skriv(f)
}

Her slipper du telleren helt — f blir hvert element etter tur. Bruk for når du går gjennom en hel liste, og mens når du trenger mer kontroll over når løkka skal stoppe.

Prøv det selv

Lagre ett av eksemplene i lokke.no og kjør:

nc run lokke.no

En liten øvelse

Prøv å endre den første løkka så den skriver partallene 0, 2, 4, 6, 8 og 10. Hint: tell med i = i + 2 i stedet for i = i + 1, og la løkka gå så lenge i <= 10. Å prøve seg fram er akkurat slik man lærer løkker.

Når løkker sitter, ta Kom i gang videre, eller bla i eksemplene.

Tell nedover

En løkke kan like gjerne telle den andre veien. Her teller vi fra 5 ned til 1:

la i = 5
mens i > 0 {
    skriv(tekst(i))
    i = i - 1
}

Det eneste som er annerledes er startverdien, betingelsen og at vi trekker fra i stedet for å legge til. Prinsippet er det samme: gjør noe, beveg deg mot slutten, gjenta.

Løkker inni løkker

Du kan ha en løkke inne i en annen. Dette skriver en liten gangetabell:

la rad = 1
mens rad <= 3 {
    la kol = 1
    mens kol <= 3 {
        skriv(tekst(rad * kol))
        kol = kol + 1
    }
    rad = rad + 1
}

Den ytre løkka går én gang per rad, og den indre kjører helt ferdig for hver av dem. Nøstede løkker er kraftige, men husk at arbeidet vokser raskt — to løkker som hver går tusen ganger, blir en million steg.

Bryt og fortsett

Noen ganger vil du ut av en løkke før betingelsen sier stopp, eller hoppe over én runde. Til det har mens to ord: bryt avslutter løkka umiddelbart, og fortsett hopper til neste runde.

la i = 0
mens i < 10 {
    i = i + 1
    hvis i == 5 { fortsett }
    hvis i == 8 { bryt }
    skriv(tekst(i))
}

Dette skriver 1, 2, 3, 4, 6 og 7 — det hopper over 5 og stopper helt ved 8.

Vanlige feil med løkker

• Evig løkke: glemmer du å bevege deg mot slutten (i = i + 1), blir betingelsen aldri usann, og programmet henger. Ser du at noe kjører uten å stoppe, er dette den vanligste årsaken.
• Én for mye eller én for lite: grensen mellom < og <= avgjør om siste verdi er med. Test alltid at løkka treffer akkurat de tallene du venter.

Øv videre

Prøv å skrive en løkke som legger sammen tallene fra 1 til 100, eller en som bare skriver partallene. Løkker er en av de tingene som sitter best når du har skrevet noen selv. Deretter er eksemplene fulle av løkker i ekte bruk.

Tilbake til oversikten