Lær alt om Golang for loops ved å kode flere nyttige eksempler.
Nylig har programmeringsspråk som Rust, Golang og TypeScript blitt superpopulære blant utviklere. Hvis du er interessert i backend-utvikling og DevOps, bør du vurdere å lære Golang er et utmerket alternativ!
Hvis du er en nybegynner som forstår det grunnleggende i et programmeringsspråk, er loop-konstruksjoner et av de første konseptene du bør forstå.
Golang gir bare for loop-konstruksjonen. Og vi vil lære om for loops og også hvordan du kan emulere andre looper ved å bruke for loop.
La oss begynne!
Innholdsfortegnelse
Syntaks av Golang For Loop
I Golang kan du lage for loop ved å bruke følgende syntaks:
for initialization; condition; update {
// do something
}
Her,
- initialisering angir initialiseringen av looping-variabelen.
- condition er sløyfebetingelsen som bestemmer utførelsen av sløyfekroppen. Så lenge looping-betingelsen evalueres til sann, blir setningene i loop-kroppen utført. Og når tilstanden blir falsk, går kontrollen ut av sløyfen.
- oppdatering angir oppdateringen til looping-variabelen – vanligvis en økning eller en reduksjon.
💡 Legg merke til hvordan dette ligner på C for loop bare uten parentes.
Her er kontrollflyten i Golang for loops:
På tide å kode noen eksempler!⏰ For å kode med kan du enten bruke en lokal installasjon av Golang eller kjøre eksemplene på Go Playground.
Golang For Loop Eksempler
La oss bruke syntaksen vi nettopp har lært til å skrive vår første for loop. Her er en enkel for-løkke som skriver ut tallene 1 til 5 i trinn på ett.
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
fmt.Println(i)
}
}
Vi initialiserer looping-variabelen i til 1, setter betingelsen til i <= 5, og øker looping-variabelen med én etter hver iterasjon. Og her er utgangen:
//Output For loop: 1 2 3 4 5
La oss skrive en annen for loop. Denne sløyfen starter fra 5 og teller ned til 1; det fortsetter til looping-variabelen er større enn eller lik 1. Så vi reduserer looping-variabelen med én etter hver iterasjon.
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := num; i >= 1; i-- {
fmt.Println(i)
}
}
Og vi får det forventede resultatet:
//Output For loop: 5 4 3 2 1
Hva er omfanget av sløyfevariabelen?
Omfanget av looping-variabelen er begrenset til for loop-blokken, og er ikke tilgjengelig utenfor loopen.
For å bekrefte dette, la oss prøve å få tilgang til verdien av looping-variabelen i utenfor loopen:
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 feil som sier at i er en udefinert (og omfanget er begrenset til for-løkken):
// Output ./prog.go:11:14: undefined: i
Infinite For Loop i Golang
Kan vi ha uendelig for loops i Go? Ja, det kan vi sikkert!
Hvis du ser på kontrollflyten til for loop:
- Løkkelegemet vil fortsette å kjøre så lenge tilstanden evalueres til sann.
- Når tilstanden blir falsk, går kontrollen ut av sløyfen.
- Så hvis betingelsen aldri blir usann (eller alltid er sann), har vi en uendelig løkke.
Men du kan også bruke for-løkken uten initialisering, tilstand og oppdatering – uten å støte på syntaksfeil. Så hvis du kan få løkken til å løpe uendelig selv ved å bruke en for løkkekonstruksjon som denne:
package main
import "fmt"
func main() {
for {
fmt.Println("running...")
}
}
//Output running... running... running... running... running... //and it goes on forever!
I dette eksemplet setter vi variabelen num til 5. Og sløyfebetingelsen er num >= 5. Så løkken løper så lenge num er større enn eller lik null.
package main
import "fmt"
func main() {
num := 5
for num > 0 {
fmt.Println(num)
}
}
Fordi verdien av num aldri endres, evalueres betingelsen alltid til sann, og løkken går for alltid!
//Output 5 5 5 5 5 5 //and it goes on forever!
All Golang har bare for loop-konstruksjonen, vi kan prøve å emulere while og do-while looper ved å bruke for loops. Så la oss lære hvordan du gjør det!
Emulering mens loop ved hjelp av For Loop
While-løkken har vanligvis følgende form:
// initialize looping var
while (condition){
// do something
// update looping var
}
Hvis du husker, skrev vi i den første infinite for loop: vi brukte følgende for loop – uten initialisering, betingelse og oppdatering.
for {
// the simplest infinite loop
}
Så vi kan endre for-løkken til å inneholde bare betingelsen (i følgende form) for å emulere while-løkken:
//initialize looping var
for condition {
// do something
// update looping var
}
Her er while-løkken som tilsvarer den første for-løkken som vi skrev:
package main
import "fmt"
func main() {
fmt.Println("Emulating while loop")
num := 5
for num > 0 {
fmt.Println(num)
num--
}
}
//Output Emulating while loop 5 4 3 2 1
Emulerer Do-While Loop ved å bruke For Loop
Hvis du har kodet i et språk som C, vet du at do-while loop-konstruksjonen har følgende form:
// initialize looping var
do {
//something
// update looping var
} while(condition);
Den viktigste forskjellen mellom while og do while loop er at while loopen sjekker tilstanden ved inntreden i loopen. Do-while-løkken, derimot, sjekker tilstanden ved utgang fra løkken.
Så, om en stund løkke, hvis betingelsen evalueres til falsk, vil løkkekroppen aldri utføres. Imidlertid, i en do-while-løkke, kjøres loop-kroppen selv om tilstanden evalueres til falsk.
Ved å bruke denne informasjonen kan vi emulere oppførselen til en do-while-løkke:
- Skriv en uendelig for loop
- Bruk en if condition-setning med riktig betingelse for å bryte ut av loopen
La oss si at du vil skrive en do-while-løkke der betingelsen for at loopbody skal utføres er num < 0. Så du kan skrive en for-løkke og bryte ut av loopen hvis num >= 0.
package main
import "fmt"
func main() {
fmt.Println("Emulating do-while loop")
num := 5
for {
fmt.Println("loop runs...")
if num >= 0 {
break
}
}
}
💡 Merk at å utføre løkken hvis num < 0 og bryte ut av løkken hvis num >= 0 er ekvivalente betingelser.
Selv om betingelsen num > 0 i utgangspunktet er usann (num er 5), kjører løkken én gang, og emulerer en do-while-løkke.
//Output Emulating do-while loop loop runs...
Looping Gjennom Arrays Bruke For Loop
Når du går gjennom arrays i Golang ved å bruke en for loop og range, kan du få tilgang til både indeksene og elementene. Dette fungerer på samme måte som enumerate-funksjonen i Python.
Her lager vi numArray, en rekke heltall. Og gå gjennom den ved å bruke en for-løkke:
package main
import "fmt"
func main() {
fmt.Println("Looping through an array")
numArray := []int{3, 7, 0, 10, 8, 9}
for idx, num := range numArray {
fmt.Println("At index", idx, ": ", num)
}
}
Som sett kan vi få tilgang til både indeksen og elementet på hver indeks samtidig:
//Output Looping through an array At index 0 : 3 At index 1 : 7 At index 2 : 0 At index 3 : 10 At index 4 : 8 At index 5 : 9
Bruke defer i Golang For Loop
I Golang kan du bruke defer nøkkelordet for å utsette funksjonskall.
Selv om det brukes i applikasjoner som ressursopprydding og feilhåndtering, kan det være nyttig å forstå hvordan du bruker defer i en for-løkke. La oss se hva som skjer når vi bruker defer inne i for-løkken for å utsette kallene til Println()-funksjonen.
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
defer fmt.Println(i)
}
}
💬 Når et funksjonskall blir utsatt, skyves funksjonskallet inn på stabelen og utføres i LIFO-rekkefølge. Denne kjøringen skjer først etter at funksjonen som omgir defer-setningen returnerer.
Så fmt.Println(5) blir utført først og fmt.Println(1) blir utført sist:
//Output For loop: 5 4 3 2 1
Konklusjon
Her er et sammendrag av det du har lært i denne opplæringen:
- I Golang kan du lage for løkker med syntaksen: for initialisering; betingelse; oppdater { //loop body}.
- Kontrollflyten til for-løkken er ganske enkel. Løkkevariabelen initialiseres én gang, letebetingelsen bestemmer om løkketeksten skal utføres eller ikke, og oppdateringen refererer til oppdateringen av løkkevariabelen etter hver iterasjon.
- Omfanget av sløyfevariabelen er begrenset til sløyfekroppen og er ikke tilgjengelig utenfor sløyfen.
- Selv om Golang bare gir for loop-konstruksjonen, kan du emulere mens- og do-while-løkke-atferd ved å bruke for loops.
- Noen få andre applikasjoner av for loop inkluderer looping gjennom arrays og utsettelse av funksjonskall inne i for loop body.
Deretter lærer du hvordan du bruker for loops i Python. God læring!🎉