Lær alt om Golang for loops ved at kode flere nyttige eksempler.
For nylig er programmeringssprog som Rust, Golang og TypeScript blevet super populære blandt udviklere. Hvis du er interesseret i back-end udvikling og DevOps, bør du overveje at lære Golang er en fremragende mulighed!
Hvis du er nybegynder, der har lært det grundlæggende i et programmeringssprog, er loop-konstruktioner et af de første begreber, du bør forstå.
Golang giver kun for loop-konstruktionen. Og vi lærer om for loops og også hvordan man emulerer andre loops ved at bruge for loop.
Lad os begynde!
Indholdsfortegnelse
Syntaks af Golang For Loop
I Golang kan du oprette til loop ved hjælp af følgende syntaks:
for initialization; condition; update {
// do something
}
Her,
- initialisering angiver initialiseringen af looping-variablen.
- betingelse er løkkebetingelsen, der bestemmer udførelsen af løkkelegemet. Så længe looping-betingelsen evalueres til sand, bliver sætningerne i loop-kroppen eksekveret. Og når tilstanden bliver falsk, forlader styringen sløjfen.
- update angiver opdateringen til looping-variablen – normalt en stigning eller en reduktion.
💡 Bemærk, hvordan dette kun ligner C for loop uden parentes.
Her er kontrolflowet i Golang for loops:
Tid til at kode nogle eksempler!⏰ For at kode med kan du enten bruge en lokal installation af Golang eller køre eksemplerne på Go Playground.
Golang For Loop Eksempler
Lad os bruge den syntaks, vi lige har lært, til at skrive vores første for loop. Her er en simpel loop, der udskriver tallene 1 op til 5 i trin af et.
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
fmt.Println(i)
}
}
Vi initialiserer looping-variablen i til 1, sætter betingelsen til i <= 5, og øger looping-variablen med én efter hver iteration. Og her er outputtet:
//Output For loop: 1 2 3 4 5
Lad os skrive en anden for loop. Denne sløjfe starter fra 5 og tæller ned til 1; det fortsætter, indtil looping-variablen er større end eller lig med 1. Så vi formindsker looping-variablen med én efter hver iteration.
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 output:
//Output For loop: 5 4 3 2 1
Hvad er omfanget af løkkevariablen?
Omfanget af looping-variablen er begrænset til for-løkke-blokken og er ikke tilgængelig uden for sløjfen.
For at bekræfte dette, lad os prøve at få adgang til værdien af looping-variablen i uden for sløjfen:
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 løber vi ind i en fejl, der angiver, at i er en udefineret (og dens omfang er begrænset til for-løkken):
// Output ./prog.go:11:14: undefined: i
Infinite For Loop i Golang
Kan vi have uendelig for loops i Go? Ja, det kan vi bestemt!
Hvis du ser på kontrolflowet for for loop:
- Løkkelegemet vil fortsætte med at udføre, så længe betingelsen evalueres til sand.
- Når betingelsen bliver falsk, forlader styringen sløjfen.
- Så hvis betingelsen aldrig bliver falsk (eller altid er sand), har vi en uendelig løkke.
Men du kan også bruge for-løkken uden initialisering, betingelse og opdatering – uden at løbe ind i syntaksfejl. Så hvis du kan få løkken til at køre uendeligt, selv ved at bruge en for-løkke-konstruktion 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 eksempel sætter vi variablen num til 5. Og sløjfebetingelsen er num >= 5. Så sløjfen kører så længe num er større end eller lig med nul.
package main
import "fmt"
func main() {
num := 5
for num > 0 {
fmt.Println(num)
}
}
Fordi værdien af num aldrig ændres, evalueres betingelsen altid til sand, og løkken kører for evigt!
//Output 5 5 5 5 5 5 //and it goes on forever!
Alle Golang har kun for loop-konstruktionen, vi kan prøve at efterligne while og do-while loops ved at bruge for loops. Så lad os lære, hvordan man gør det!
Emulering under loop ved hjælp af For Loop
While-løkken har generelt følgende form:
// initialize looping var
while (condition){
// do something
// update looping var
}
Hvis du husker det, skrev vi i den første infinite for loop: vi brugte følgende for loop – uden initialisering, betingelse og opdatering.
for {
// the simplest infinite loop
}
Så vi kan ændre for-løkken til kun at indeholde betingelsen (i følgende form) for at emulere while-løkken:
//initialize looping var
for condition {
// do something
// update looping var
}
Her er while-løkken, der svarer til den første for-løkke, 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
Emulering af Do-While Loop ved hjælp af For Loop
Hvis du har kodet i et sprog som C, ved du, at do-while loop-konstruktionen har følgende form:
// initialize looping var
do {
//something
// update looping var
} while(condition);
Den vigtigste forskel mellem while og do while loop er, at while loop kontrollerer tilstanden ved indtræden i loopen. Do-while-løkken, på den anden side, kontrollerer tilstanden ved udgang fra løkken.
Så hvis betingelsen om et stykke tid evalueres til falsk, udføres loop-kroppen aldrig. I en do-while-løkke udføres loop-kroppen dog, selvom betingelsen evalueres til falsk.
Ved at bruge disse oplysninger kan vi efterligne adfærden af en do-while loop:
- Skriv en uendelig for loop
- Brug et if condition-udsagn med den korrekte betingelse for at bryde ud af løkken
Lad os sige, at du vil skrive en do-while-løkke, hvor betingelsen for, at løkkelegemet kan udføres, er num < 0. Så du kan skrive en for-løkke og bryde ud af løkken, 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
}
}
}
💡 Bemærk, at udførelse af løkken, hvis num < 0 og bryde ud af løkken, hvis num >= 0 er ækvivalente betingelser.
Selvom betingelsen num > 0 oprindeligt er falsk (num er 5), kører løkkens krop én gang og emulerer en do-while-løkke.
//Output Emulating do-while loop loop runs...
Looping Gennem Arrays Brug For Loop
Når du går gennem arrays i Golang ved hjælp af en for loop og range, kan du få adgang til både indekserne og elementerne. Dette fungerer på samme måde som enumerate-funktionen i Python.
Her opretter vi numArray, en matrix af heltal. Og sløj gennem den ved hjælp af 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 det ses, er vi i stand til at få adgang til både indekset og elementet ved hvert indeks samtidigt:
//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
Brug af defer i Golang For Loop
I Golang kan du bruge nøgleordet defer til at udskyde funktionskald.
Selvom det bruges i applikationer som ressourceoprydning og fejlhåndtering, kan det være nyttigt at forstå, hvordan man bruger defer inde i en for-løkke. Lad os se, hvad der sker, når vi bruger defer inde i for-løkken til at udskyde kaldene til Println()-funktionen.
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 funktionskald udskydes, skubbes funktionskaldet ind på stakken og udføres i LIFO-rækkefølge. Denne udførelse sker først, efter at funktionen, der omgiver udsættelsessætningen, returnerer.
Så fmt.Println(5) bliver eksekveret først og fmt.Println(1) bliver eksekveret sidst:
//Output For loop: 5 4 3 2 1
Konklusion
Her er en oversigt over, hvad du har lært i denne øvelse:
- I Golang kan du oprette for loops med syntaksen: for initialisering; tilstand; opdater { //loop body}.
- Kontrolflowet af for-løkken er ret simpelt. Sløjfevariablen initialiseres én gang, søgebetingelsen bestemmer, om løkketeksten skal udføres eller ej, og opdateringen refererer til opdateringen af sløjfevariablen efter hver iteration.
- Omfanget af sløjfevariablen er begrænset til sløjfekroppen og er ikke tilgængelig uden for sløjfen.
- Selvom Golang kun giver for loop-konstruktionen, kan du efterligne while og do-while loop adfærd ved at bruge for loops.
- Et par andre anvendelser af for loop inkluderer looping gennem arrays og udsættelse af funktionskald inde i for loop body.
Lær derefter, hvordan du bruger til loops i Python. God læring!🎉