Upptäck alla detaljer om loopar i Golang genom att studera och applicera ett flertal praktiska exempel.
På senare tid har programmeringsspråk som Rust, Golang och TypeScript vunnit stor popularitet bland programmerare. Om backend-utveckling och DevOps intresserar dig, är det väl värt att utforska Golang som ett potent alternativ!
För de som är nya inom programmering, är loopstrukturer ett av de första fundamenten som man bör bemästra.
Golang erbjuder enbart for-loopkonstruktionen. Vi kommer att undersöka for-loopar samt se hur man simulerar andra looptyper med hjälp av for-loopen.
Låt oss sätta igång!
Syntax för Golangs For-loop
I Golang kan en for-loop skapas enligt följande struktur:
for initiering; villkor; uppdatering {
// utför operationer
}
Här betecknar:
- initiering startvärdet för loopvariabeln.
- villkor avgör om loopen ska fortsätta. Så länge villkoret är sant, utförs koden i loopens kropp. När villkoret blir falskt avslutas loopen.
- uppdatering justerar loopvariabeln, vanligtvis genom ökning eller minskning.
💡 Notera att detta liknar C:s for-loop, men utan parenteserna.
Här följer schematiska flödet för for-loopar i Golang:
Dags att utforska lite kod! ⏰ För att experimentera kan du antingen använda en lokal installation av Golang eller Go Playground för att köra exemplen.
Exempel på Golangs For-loop
Låt oss använda strukturen vi just lärt oss för att skapa vår första for-loop. Här är en enkel loop som skriver ut talen 1 till 5 i stigande ordning.
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
fmt.Println(i)
}
}
Vi initierar loopvariabeln i till 1, ställer in villkoret till i <= 5, och ökar loopvariabeln med ett i varje iteration. Här är utdata:
//Utdata
For loop:
1
2
3
4
5
Låt oss skapa en annan for-loop. Denna loop börjar på 5 och räknar ner till 1; den fortsätter så länge loopvariabeln är större än eller lika med 1. Vi minskar då loopvariabeln med ett i varje steg.
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := num; i >= 1; i-- {
fmt.Println(i)
}
}
Vi erhåller följande förväntade utdata:
//Utdata
For loop:
5
4
3
2
1
Vad är loopvariabelns räckvidd?
Loopvariabelns räckvidd är begränsat till for-loopblocket och är otillgängligt utanför loopen.
För att bekräfta detta, låt oss försöka komma åt loopvariabeln i utanför 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 väntat får vi ett felmeddelande som indikerar att i är odefinierat (och dess omfattning är begränsad till for-loopen):
// Utdata
./prog.go:11:14: undefined: i
Oändlig For-loop i Golang
Kan vi ha oändliga for-loopar i Go? Ja, det är fullt möjligt!
Om vi betraktar for-loopens flöde:
- Loopkroppen fortsätter att exekvera så länge som villkoret utvärderas till sant.
- När villkoret blir falskt avslutas loopen.
- Alltså, om villkoret aldrig blir falskt (eller alltid är sant) har vi en oändlig loop.
Men du kan också använda for-loopen utan initiering, villkor och uppdatering – utan att stöta på syntaxfel. Alltså, vi kan få loopen att snurra oändligt även med en for-loopkonstruktion som denna:
package main
import "fmt"
func main() {
for {
fmt.Println("körs...")
}
}
//Utdata
körs...
körs...
körs...
körs...
körs...
//och så vidare i all evighet!
I det här exemplet ställer vi in variabeln num till 5. Och loopvillkoret är num > 0. Så loopen körs så länge num är större än noll.
package main
import "fmt"
func main() {
num := 5
for num > 0 {
fmt.Println(num)
}
}
Eftersom värdet på num aldrig förändras, kommer villkoret alltid att utvärderas som sant, och loopen kommer att snurra oändligt!
//Utdata
5
5
5
5
5
5
//och så vidare i all evighet!
Eftersom Golang enbart erbjuder for-loopkonstruktionen kan vi försöka efterlikna while- och do-while-loopar med hjälp av for-loopar. Så låt oss lära oss hur det görs!
Efterlikna While-loop med hjälp av For-loop
En while-loop har oftast följande form:
// initiera loopvariabel
while (villkor){
// utför operationer
// uppdatera loopvariabel
}
Som du kanske minns använde vi den enklaste oändliga for-loopen: utan initiering, villkor och uppdatering.
for {
// den enklaste oändliga loopen
}
Vi kan modifiera for-loopen så att den endast innehåller villkoret (i följande form) för att simulera en while-loop:
// initiera loopvariabel
for villkor {
// utför operationer
// uppdatera loopvariabel
}
Här är while-loopens motsvarighet till den första for-loopen vi skapade:
package main
import "fmt"
func main() {
fmt.Println("Simulerar while-loop")
num := 5
for num > 0 {
fmt.Println(num)
num--
}
}
//Utdata
Simulerar while-loop
5
4
3
2
1
Efterlikna Do-While-loop med For-loop
Om du har kodat i språk som C, vet du att do-while-loopstrukturen ser ut så här:
// initiera loopvariabel
do {
//något
// uppdatera loopvariabel
} while(villkor);
Den största skillnaden mellan while- och do-while-loopen är att while-loopen kontrollerar villkoret vid ingången av loopen. Do-while-loopen kontrollerar däremot villkoret vid utgången av loopen.
I en while-loop kommer loopkroppen aldrig att köras om villkoret initialt är falskt. I en do-while-loop körs loopkroppen åtminstone en gång, även om villkoret initialt är falskt.
Med denna kunskap kan vi imitera beteendet hos en do-while-loop genom att:
- Skapa en oändlig for-loop
- Använda en if-sats med rätt villkor för att avbryta loopen.
Låt oss anta att du vill skapa en do-while-loop där villkoret för att köra loopkroppen är num < 0. Då kan du skapa en for-loop och bryta loopen om num >= 0.
package main
import "fmt"
func main() {
fmt.Println("Simulerar do-while-loop")
num := 5
for {
fmt.Println("loopen körs...")
if num >= 0 {
break
}
}
}
💡 Observera att exekvering av loopen om num < 0 och avbrytande av loopen om num >= 0 är ekvivalenta villkor.
Även om villkoret num > 0 initialt är falskt (num är 5), kommer loopkroppen att köras en gång, vilket simulerar en do-while-loop.
//Utdata
Simulerar do-while-loop
loopen körs...
Loopa genom Arrayer med For-loop
När du loopar genom arrayer i Golang med hjälp av en for-loop och range, kan du komma åt både index och element. Detta fungerar på liknande sätt som enumerate-funktionen i Python.
Här skapar vi numArray, en array av heltal, och loopar genom den med en for-loop:
package main
import "fmt"
func main() {
fmt.Println("Loopar genom en array")
numArray := []int{3, 7, 0, 10, 8, 9}
for idx, num := range numArray {
fmt.Println("Vid index", idx, ": ", num)
}
}
Som vi ser kan vi komma åt både indexet och elementet samtidigt:
//Utdata
Loopar genom en array
Vid index 0 : 3
Vid index 1 : 7
Vid index 2 : 0
Vid index 3 : 10
Vid index 4 : 8
Vid index 5 : 9
Använda Defer i Golangs For-loop
I Golang kan du använda nyckelordet defer för att skjuta upp funktionsanrop.
Även om det används i applikationer som resurshantering och felhantering, är det värdefullt att förstå hur man använder defer inuti en for-loop. Låt oss se vad som händer när vi använder defer inuti for-loopen för att skjuta upp anropen till 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 ett funktionsanrop skjuts upp läggs det på stacken och exekveras i LIFO-ordning (Last In, First Out). Denna exekvering sker först efter att funktionen som omger defer-satsen returnerar.
Därför kommer fmt.Println(5) att exekveras först och fmt.Println(1) sist:
//Utdata
For loop:
5
4
3
2
1
Slutsats
Här följer en sammanfattning av vad du har lärt dig i den här handledningen:
- I Golang skapar man for-loopar med syntaxen: for initiering; villkor; uppdatering { // loopkropp }.
- Flödet för for-loopen är ganska okomplicerat. Loopvariabeln initieras en gång, villkoret avgör om loopkroppen ska köras eller inte, och uppdateringen sker efter varje iteration.
- Loopvariabelns räckvidd är begränsat till loopkroppen och är otillgänglig utanför loopen.
- Trots att Golang enbart erbjuder for-loopkonstruktionen, kan du efterlikna while- och do-while-looparnas beteende med hjälp av for-loopar.
- Andra tillämpningar av for-loopen är att loopa genom arrayer och att skjuta upp funktionsanrop inuti loopens kropp.
Utforska gärna hur man använder for-loopar i Python. Lycka till med inlärningen! 🎉