Lär dig allt om Golang för loopar genom att koda flera användbara exempel.
Nyligen har programmeringsspråk som Rust, Golang och TypeScript blivit superpopulära bland utvecklare. Om du är intresserad av backend-utveckling och DevOps bör du överväga att lära dig Golang är ett utmärkt alternativ!
Om du är nybörjare och plockar upp grunderna i ett programmeringsspråk, är loop-konstruktioner ett av de första begreppen du bör förstå.
Golang tillhandahåller endast for loop-konstruktionen. Och vi kommer att lära oss om for loopar och även hur man emulerar andra loopar med för loop.
Låt oss börja!
Innehållsförteckning
Syntax för Golang For Loop
I Golang kan du skapa för loop med följande syntax:
for initialization; condition; update {
// do something
}
Här,
- initiering anger initieringen av loopingvariabeln.
- condition är looping-villkoret som bestämmer exekveringen av loopkroppen. Så länge loopingvillkoret utvärderas till sant, exekveras satserna i loopkroppen. Och när villkoret blir falskt lämnar kontrollen slingan.
- update anger uppdateringen av looping-variabeln—vanligtvis ett inkrement eller en dekrement.
💡 Lägg märke till hur detta liknar C for loop endast utan parentes.
Här är kontrollflödet i Golang för loopar:
Dags att koda några exempel!⏰ För att koda med kan du antingen använda en lokal installation av Golang eller köra exemplen på Go Playground.
Golang för loopexempel
Låt oss använda syntaxen vi just har lärt oss för att skriva vår första för loop. Här är en enkel slinga som skriver ut siffrorna 1 upp till 5 i steg om ett.
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
fmt.Println(i)
}
}
Vi initierar loopingvariabeln i till 1, ställer in villkoret till i <= 5 och ökar loopingvariabeln med en efter varje iteration. Och här är resultatet:
//Output For loop: 1 2 3 4 5
Låt oss skriva en annan för loop. Denna loop börjar från 5 och räknar ner till 1; det fortsätter tills looping-variabeln är större än eller lika med 1. Så vi minskar looping-variabeln med en efter varje iteration.
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := num; i >= 1; i-- {
fmt.Println(i)
}
}
Och vi får den förväntade produktionen:
//Output For loop: 5 4 3 2 1
Vad är omfattningen av loopingvariabeln?
Omfattningen av looping-variabeln är begränsad till for loop-blocket och är inte tillgänglig utanför loopen.
För att verifiera detta, låt oss försöka komma åt värdet för loopingvariabeln 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 förväntat stöter vi på ett fel som säger att i är en odefinierad (och dess omfattning är begränsad till for-slingan):
// Output ./prog.go:11:14: undefined: i
Oändlig för loop i Golang
Kan vi ha oändligt för loopar i Go? Ja, det kan vi säkert!
Om du tittar på kontrollflödet för for loop:
- Slingkroppen kommer att fortsätta att exekvera så länge som villkoret utvärderas till sant.
- När villkoret blir falskt lämnar kontrollen slingan.
- Så 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. Så om du kan få slingan att köras oändligt även med en for-loopkonstruktion så här:
package main
import "fmt"
func main() {
for {
fmt.Println("running...")
}
}
//Output running... running... running... running... running... //and it goes on forever!
I det här exemplet sätter vi variabeln num till 5. Och loopingvillkoret är num >= 5. Så slingan löper så länge som num är större än eller lika med noll.
package main
import "fmt"
func main() {
num := 5
for num > 0 {
fmt.Println(num)
}
}
Eftersom värdet på num aldrig ändras, evalueras villkoret alltid till sant, och slingan löper för alltid!
//Output 5 5 5 5 5 5 //and it goes on forever!
All Golang har bara for loop-konstruktionen, vi kan försöka emulera while och do-while loopar med för loopar. Så låt oss lära oss hur man gör det!
Emulering medan loop med hjälp av For Loop
While-slingan har vanligtvis följande form:
// initialize looping var
while (condition){
// do something
// update looping var
}
Om du minns, i den första infinite for loop skrev vi: vi använde följande för loop – utan initialisering, villkor och uppdatering.
for {
// the simplest infinite loop
}
Så vi kan modifiera for-slingan så att den bara innehåller villkoret (i följande form) för att emulera while-slingan:
//initialize looping var
for condition {
// do something
// update looping var
}
Här är while-slingans motsvarighet till den första för loop 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
Emulera Do-While Loop med For Loop
Om du har kodat i ett språk som C, vet du att do-while loop-konstruktionen har följande form:
// initialize looping var
do {
//something
// update looping var
} while(condition);
Den viktigaste skillnaden mellan while och do while loop är att while loopen kontrollerar tillståndet vid inträde i loopen. Do-while-slingan, å andra sidan, kontrollerar tillståndet vid utgång från slingan.
Så, om en stunds loop, om villkoret utvärderas till falskt, exekveras aldrig loopkroppen. Men i en do-while-loop körs loopkroppen även om villkoret utvärderas till falskt.
Med hjälp av denna information kan vi emulera beteendet hos en do-while loop:
- Skriv en oändlig för loop
- Använd en if conditional-sats med rätt villkor för att bryta ut ur loopen
Säg att du vill skriva en do-while-slinga där villkoret för att loopkroppen ska köras är num < 0. Så du kan skriva en for-loop och bryta ut ur loopen om 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
}
}
}
💡 Observera att exekvering av loopen om num < 0 och att bryta ut ur loopen om num >= 0 är ekvivalenta villkor.
Även om villkoret num > 0 initialt är falskt (num är 5), kör loopkroppen en gång och emulerar en do-while loop.
//Output Emulating do-while loop loop runs...
Looping Genom Arrays Användning 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 indexen och elementen. Detta fungerar på samma sätt som enumerate-funktionen i Python.
Här skapar vi numArray, en array av heltal. Och gå igenom den med en for-loop:
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 komma åt både indexet och elementet vid varje index 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
Använda defer i Golang For Loop
I Golang kan du använda nyckelordet defer för att skjuta upp funktionsanrop.
Även om det används i applikationer som resursrensning och felhantering, kan det vara bra 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, skjuts funktionsanropet till stacken och exekveras i LIFO-ordning. Denna körning sker först efter att funktionen som omger defer-satsen returneras.
Så fmt.Println(5) exekveras först och fmt.Println(1) exekveras sist:
//Output For loop: 5 4 3 2 1
Slutsats
Här är en sammanfattning av vad du har lärt dig i den här självstudien:
- I Golang kan du skapa för loopar med syntaxen: för initialisering; skick; uppdatera { //loop body}.
- Kontrollflödet för for-slingan är ganska enkelt. Slingvariabeln initieras en gång, sökvillkoret avgör om loopkroppen ska exekveras eller inte, och uppdateringen hänvisar till uppdateringen av loopingvariabeln efter varje iteration.
- Omfattningen av looping-variabeln är begränsad till loopkroppen och är inte tillgänglig utanför loopen.
- Även om Golang endast tillhandahåller for loop-konstruktionen, kan du emulera while och do-while loop beteenden med for loopar.
- Några andra tillämpningar av for loop inkluderar looping genom arrayer och uppskjutande funktionsanrop inuti for loop body.
Lär dig sedan hur du använder för loopar i Python. Lycka till med lärandet!🎉