En grundig introduksjon til Golang for-løkker
I den moderne utviklingsverdenen har programmeringsspråk som Rust, Golang og TypeScript oppnådd stor popularitet. Hvis du er interessert i backend-utvikling eller DevOps, er det absolutt verdt å vurdere å lære Golang!
For nybegynnere er forståelsen av loop-konstruksjoner et av de første viktige trinnene. Disse strukturene lar oss gjenta kodeblokker, noe som er avgjørende for mange programmeringsoppgaver.
Golang tilbyr kun én type loop, nemlig «for»-løkken. I denne artikkelen skal vi utforske denne konstruksjonen i dybden, samt se hvordan «for»-løkken kan brukes til å emulere andre typer løkker.
La oss komme i gang!
Syntaks for Golang «for»-løkke
Grunnleggende «for»-løkker i Golang har denne strukturen:
for initialisering; betingelse; oppdatering {
// Kode som skal repeteres
}
La oss se nærmere på hva hver del betyr:
- initialisering: Her defineres og initieres løkkevariabelen.
- betingelse: Dette er vilkåret som styrer hvor lenge løkken skal fortsette å kjøre. Så lenge betingelsen er sann, vil koden inne i løkken bli utført. Når betingelsen evalueres til usann, stopper løkken.
- oppdatering: Dette er et uttrykk som endrer løkkevariabelen etter hver iterasjon, vanligvis ved å øke eller redusere den.
💡 Legg merke til likheten med «for»-løkker i C, men uten parenteser.
Slik fungerer kontrollflyten i Golang «for»-løkker:
Nå er det på tide å se på noen praktiske eksempler! Du kan skrive og kjøre koden enten lokalt på datamaskinen din med Golang installert, eller direkte i Go Playground.
Eksempler på Golang «for»-løkker
La oss anvende det vi nettopp har lært og skrive vår første «for»-løkke. Dette eksemplet skriver ut tallene fra 1 til 5, ett tall om gangen:
package main
import "fmt"
func main() {
fmt.Println("For løkke:")
num := 5
for i := 1; i <= num; i++ {
fmt.Println(i)
}
}
Her initierer vi løkkevariabelen `i` til 1, setter betingelsen til `i <= 5`, og øker `i` med 1 for hver iterasjon. Resultatet er:
//Output For løkke: 1 2 3 4 5
La oss se på et annet eksempel. Denne løkken starter med 5 og teller ned til 1. Løkken fortsetter så lenge løkkevariabelen er større enn eller lik 1. For hver iterasjon reduseres løkkevariabelen med 1.
package main
import "fmt"
func main() {
fmt.Println("For løkke:")
num := 5
for i := num; i >= 1; i-- {
fmt.Println(i)
}
}
Og resultatet blir som forventet:
//Output For løkke: 5 4 3 2 1
Hva er omfanget til løkkevariabelen?
Løkkevariabelens omfang er begrenset til selve «for»-løkkeblokken. Dette betyr at den ikke kan brukes utenfor løkken.
For å bekrefte dette, la oss prøve å aksessere verdien til `i` utenfor løkken:
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
fmt.Println(i)
}
fmt.Println(i)
}
Som forventet får vi en feilmelding som sier at `i` er udefinert:
// Output ./prog.go:11:14: undefined: i
Uendelig «for»-løkke i Golang
Kan vi skape uendelige «for»-løkker i Golang? Svaret er ja, absolutt!
Når vi ser på hvordan en «for»-løkke fungerer:
- Løkken vil fortsette å kjøre så lenge betingelsen er sann.
- Når betingelsen blir usann, avsluttes løkken.
- Dette betyr at hvis betingelsen aldri blir usann, vil vi ha en uendelig løkke.
Det er også mulig å bruke en «for»-løkke uten initialisering, betingelse eller oppdatering, og dette gir ikke en syntaksfeil. Derfor kan en uendelig løkke lages ved å bruke en «for»-konstruksjon som dette:
package main
import "fmt"
func main() {
for {
fmt.Println("kjører...")
}
}
//Output kjører... kjører... kjører... kjører... kjører... //og det fortsetter i det uendelige!
I dette eksemplet setter vi variabelen `num` til 5. Betingelsen for løkken er `num > 0`. Derfor vil løkken kjøre så lenge num er større enn 0.
package main
import "fmt"
func main() {
num := 5
for num > 0 {
fmt.Println(num)
}
}
Siden verdien til `num` aldri endres, vil betingelsen alltid være sann, og løkken vil fortsette i det uendelige!
//Output 5 5 5 5 5 5 //og det fortsetter i det uendelige!
Siden Golang kun har «for»-løkken, kan vi bruke den til å simulere «while»- og «do-while»-løkker. La oss se hvordan det gjøres!
Simulere «while»-løkke med «for»-løkke
En «while»-løkke har vanligvis denne formen:
// initialiser løkkevariabel
while (betingelse){
// kode som skal utføres
// oppdater løkkevariabel
}
Som vi så tidligere, kan vi lage en uendelig «for»-løkke slik:
for {
//den enkleste uendelige løkken
}
For å etterligne en «while»-løkke, kan vi modifisere «for»-løkken slik at den bare inneholder en betingelse:
// initialiser løkkevariabel
for betingelse {
// kode som skal utføres
// oppdater løkkevariabel
}
Her er en «while»-løkke som tilsvarer den første «for»-løkken vi skrev:
package main
import "fmt"
func main() {
fmt.Println("Simulere while-løkke")
num := 5
for num > 0 {
fmt.Println(num)
num--
}
}
//Output Simulere while-løkke 5 4 3 2 1
Simulere «do-while»-løkke med «for»-løkke
Hvis du har erfaring med C eller liknende språk, vet du at en «do-while»-løkke har følgende struktur:
// initialiser løkkevariabel
do {
// kode som skal utføres
// oppdater løkkevariabel
} while(betingelse);
Den viktigste forskjellen mellom «while»- og «do-while»-løkker er at «while»-løkken sjekker betingelsen før løkken kjører, mens «do-while»-løkken sjekker betingelsen etter løkken har kjørt.
Dette betyr at i en «while»-løkke vil ikke koden i løkken bli utført hvis betingelsen er usann fra starten. I en «do-while»-løkke vil koden derimot alltid bli utført minst én gang, selv om betingelsen er usann.
For å emulere en «do-while»-løkke, kan vi gjøre følgende:
- Lag en uendelig «for»-løkke.
- Bruk en if-setning med den riktige betingelsen for å avslutte løkken.
La oss si at du ønsker å skrive en «do-while»-løkke der koden skal utføres så lenge `num` er mindre enn 0. Du kan da skrive en «for»-løkke og avslutte den hvis `num` er større enn eller lik 0.
package main
import "fmt"
func main() {
fmt.Println("Simulere do-while-løkke")
num := 5
for {
fmt.Println("løkken kjører...")
if num >= 0 {
break
}
}
}
💡 Merk at å kjøre løkken så lenge `num` er mindre enn 0, og å avslutte løkken hvis `num` er større enn eller lik 0 er ekvivalente betingelser.
Selv om betingelsen `num > 0` i utgangspunktet er usann (num er 5), vil løkken kjøre en gang og simulere en «do-while»-løkke.
//Output Simulere do-while-løkke løkken kjører...
Gå gjennom arrays ved bruk av «for»-løkke
Når du går gjennom arrays i Golang med en «for»-løkke og `range`, har du tilgang til både indeksen og verdien på hvert element. Dette ligner på `enumerate`-funksjonen i Python.
Her definerer vi en array av heltall kalt `numArray`, og bruker en «for»-løkke for å gå gjennom den:
package main
import "fmt"
func main() {
fmt.Println("Går gjennom en array")
numArray := []int{3, 7, 0, 10, 8, 9}
for idx, num := range numArray {
fmt.Println("På indeks", idx, ": ", num)
}
}
Som du ser, kan vi aksessere både indeksen og elementet på hver indeks samtidig:
//Output Går gjennom en array På indeks 0 : 3 På indeks 1 : 7 På indeks 2 : 0 På indeks 3 : 10 På indeks 4 : 8 På indeks 5 : 9
Bruk av `defer` i Golang «for»-løkke
I Golang kan du bruke nøkkelordet `defer` for å utsette funksjonskall.
Dette er spesielt nyttig for ressursopprydding og feilhåndtering, men det kan også være nyttig å vite hvordan `defer` fungerer i en «for»-løkke. La oss se hva som skjer når vi bruker `defer` inne i en «for»-løkke for å utsette kall til `Println()`-funksjonen.
package main
import "fmt"
func main() {
fmt.Println("For løkke:")
num := 5
for i := 1; i <= num; i++ {
defer fmt.Println(i)
}
}
💬 Når et funksjonskall blir utsatt, blir det lagt til i en stakk og utført i LIFO-rekkefølge (Last In, First Out). Denne utførelsen skjer først etter at funksjonen som inneholder `defer`-setningen returnerer.
Dette betyr at `fmt.Println(5)` blir utført først og `fmt.Println(1)` blir utført sist:
//Output For løkke: 5 4 3 2 1
Konklusjon
Her er en oppsummering av det du har lært i denne artikkelen:
- I Golang lager du «for»-løkker ved hjelp av syntaksen: `for initialisering; betingelse; oppdatering { //løkkekropp }`.
- Kontrollflyten i en «for»-løkke er enkel. Løkkevariabelen initialiseres én gang, betingelsen bestemmer om løkkekroppen skal kjøres, og oppdateringen endrer løkkevariabelen etter hver iterasjon.
- Omfanget til en løkkevariabel er begrenset til løkkekroppen.
- Selv om Golang bare har en «for»-løkke, kan du simulere atferden til «while»- og «do-while»-løkker ved å bruke «for»-løkker.
- Andre bruksområder for «for»-løkker inkluderer å gå gjennom arrays og utsette funksjonskall ved bruk av `defer`.
Neste skritt er å utforske hvordan du kan bruke «for»-løkker i Python. Lykke til med læringen! 🎉