Több hasznos példa kódolásával mindent megtudhat a Golang for loops-ról.
Az utóbbi időben az olyan programozási nyelvek, mint a Rust, a Golang és a TypeScript, rendkívül népszerűvé váltak a fejlesztők körében. Ha érdekli a háttérfejlesztés és a DevOps, érdemes megfontolni, hogy a Golang tanulása kiváló lehetőség!
Ha Ön kezdő, aki egy programozási nyelv alapjait ismeri, a hurokkonstrukciók az egyik első olyan fogalom, amelyet meg kell értenie.
A Golang csak a for ciklus konstrukciót biztosítja. Megtanuljuk a for ciklusokat és azt is, hogyan emulálhatunk más ciklusokat a for ciklus használatával.
Kezdjük!
A Golang For Loop szintaxisa
A Golang nyelven a következő szintaxis használatával hozhat létre ciklust:
for initialization; condition; update {
// do something
}
Itt,
- Az inicializálás a hurokváltozó inicializálását jelöli.
- A feltétel a ciklustörzs feltétele, amely meghatározza a huroktest végrehajtását. Amíg a hurokfeltétel kiértékelése igaz, a ciklustörzsben lévő utasítások végrehajtásra kerülnek. És amikor a feltétel hamis lesz, a vezérlő kilép a hurokból.
- Az update a hurokváltozó frissítését jelöli – általában növekményt vagy csökkentést.
💡 Figyeld meg, hogy ez mennyire hasonlít a C for ciklushoz, csak a zárójelek nélkül.
Íme a Golang for loops vezérlési folyamata:
Ideje kódolni néhány példát!⏰ A kódoláshoz használhatja a Golang helyi telepítését, vagy futtathatja a példákat a Go Playgroundon.
Golang For Loop Példák
Használjuk a most megtanult szintaxist az első for ciklus írásához. Itt van egy egyszerű for ciklus, amely 1-től 5-ig nyomtatja ki a számokat egyenkénti lépésekben.
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
fmt.Println(i)
}
}
Az i hurokváltozót 1-re inicializáljuk, a feltételt i <= 5-re állítjuk, és minden iteráció után eggyel növeljük a hurokváltozót. És íme a kimenet:
//Output For loop: 1 2 3 4 5
Írjunk még egy ciklust. Ez a ciklus 5-től kezdődik és 1-ig számol vissza; addig megy, amíg a hurokváltozó nagyobb vagy egyenlő nem lesz 1-nél. Tehát minden iteráció után eggyel csökkentjük a ciklusváltozót.
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := num; i >= 1; i-- {
fmt.Println(i)
}
}
És megkapjuk a várt kimenetet:
//Output For loop: 5 4 3 2 1
Mi a hurokváltozó hatóköre?
A hurokváltozó hatóköre a for hurok blokkra korlátozódik, és a hurkon kívül nem érhető el.
Ennek ellenőrzésére próbáljuk meg elérni az i hurokváltozó értékét a cikluson kívül:
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
fmt.Println(i)
}
fmt.Println(i)
}
Ahogy az várható volt, egy hibába ütközünk, amely szerint az i egy nem definiált (és hatóköre a for ciklusra korlátozódik):
// Output ./prog.go:11:14: undefined: i
Infinite For Loop Golangban
Lehet-e végtelen for ciklus a Go-ban? Igen, biztosan tudunk!
Ha megnézi a for ciklus vezérlési folyamatát:
- A ciklustörzs mindaddig fut, amíg a feltétel igazra értékelődik.
- Ha a feltétel hamis lesz, a vezérlő kilép a hurokból.
- Tehát ha a feltétel soha nem válik hamissá (vagy mindig igaz), akkor végtelen ciklusunk van.
De használhatja a for ciklust inicializálás, feltétel és frissítés nélkül is – anélkül, hogy szintaktikai hibákba ütközne. Tehát, ha a ciklus végtelenségig futhat még egy ilyen for ciklus konstrukcióval is:
package main
import "fmt"
func main() {
for {
fmt.Println("running...")
}
}
//Output running... running... running... running... running... //and it goes on forever!
Ebben a példában a num változót 5-re állítjuk. És a hurokfeltétel: num >= 5. Tehát a ciklus addig fut, amíg a num nagyobb vagy egyenlő nullával.
package main
import "fmt"
func main() {
num := 5
for num > 0 {
fmt.Println(num)
}
}
Mivel a num értéke soha nem változik, a feltétel mindig igazra értékelődik, és a ciklus örökké fut!
//Output 5 5 5 5 5 5 //and it goes on forever!
Minden Golang csak a for ciklus konstrukcióval rendelkezik, megpróbálhatjuk emulálni a while és a do-while ciklusokat a for ciklusok használatával. Tehát tanuljuk meg, hogyan kell csinálni!
A While Loop emulálása a For Loop használatával
A while ciklus általában a következő formában jelenik meg:
// initialize looping var
while (condition){
// do something
// update looping var
}
Ha emlékszel, az első végtelen for ciklusban ezt írtuk: a következőt használtuk for ciklushoz – inicializálás, feltétel és frissítés nélkül.
for {
// the simplest infinite loop
}
Tehát módosíthatjuk a for ciklust úgy, hogy csak a feltételt tartalmazza (a következő formában), hogy emuláljuk a while ciklust:
//initialize looping var
for condition {
// do something
// update looping var
}
Íme a while ciklus megfelelője az első for ciklusnak, amelyet írtunk:
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
Do-While Loop emulálása a For Loop használatával
Ha olyan nyelven kódolt, mint a C, akkor tudja, hogy a do-while cikluskonstrukció a következő formájú:
// initialize looping var
do {
//something
// update looping var
} while(condition);
A while és a do while ciklus közötti legfontosabb különbség az, hogy a while ciklus a ciklusba való belépéskor ellenőrzi a feltételeket. A do-while ciklus viszont ellenőrzi a feltételt a ciklusból való kilépéskor.
Tehát egy while ciklusban, ha a feltétel hamisra értékelődik, a ciklus törzse soha nem hajtódik végre. Azonban egy do-while ciklusban a ciklustörzs akkor is végrehajtódik, ha a feltétel hamisra értékelődik.
Ezen információk felhasználásával emulálhatjuk a do-while ciklus viselkedését:
- Írj egy végtelen for ciklust
- Használjon if feltételes utasítást a megfelelő feltétellel, hogy kitörjön a ciklusból
Tegyük fel, hogy egy do-while ciklust szeretne írni, ahol a ciklustest végrehajtásának feltétele num < 0. Tehát írhat egy for ciklust, és kitörhet a ciklusból, ha 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
}
}
}
💡 Vegye figyelembe, hogy a ciklus végrehajtása, ha szám < 0, és a ciklusból való kitörés, ha szám >= 0, egyenértékű feltételek.
Bár a num > 0 feltétel kezdetben hamis (a szám 5), a ciklustörzs egyszer lefut, emulálva a do-while ciklust.
//Output Emulating do-while loop loop runs...
Hurkolás tömbökön keresztül a For Loop használatával
Amikor a Golang tömbjein for ciklust és tartományt használ, elérheti az indexeket és az elemeket is. Ez hasonlóan működik, mint a Python felsorolás funkciója.
Itt létrehozunk numArray-t, egész számok tömbjét. És ismételje meg a for ciklust:
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)
}
}
Amint látható, egyszerre érhetjük el az indexet és az egyes indexek elemeit:
//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
Halasztás használata a Golang For Loopban
A Golang nyelven a defer kulcsszót használhatja a függvényhívások elhalasztására.
Bár olyan alkalmazásokban használják, mint például az erőforrás-tisztítás és a hibakezelés, hasznos lehet megérteni, hogyan kell használni a késleltetést a for cikluson belül. Nézzük meg, mi történik, ha a for cikluson belül a defer funkciót használjuk a Println() függvény hívásainak elhalasztására.
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
defer fmt.Println(i)
}
}
💬 Amikor egy függvényhívást elhalasztanak, a függvényhívás a verembe kerül, és LIFO sorrendben kerül végrehajtásra. Ez a végrehajtás csak azután történik meg, hogy a defer utasítást körülvevő függvény visszatér.
Tehát az fmt.Println(5) fut először, és az fmt.Println(1) utoljára:
//Output For loop: 5 4 3 2 1
Következtetés
Íme egy összefoglaló az oktatóanyagban tanultakról:
- A Golang nyelven a következő szintaxissal hozhat létre ciklusokat: inicializáláshoz; feltétel; frissítés { //loop body}.
- A for hurok vezérlési folyamata meglehetősen egyszerű. A hurokváltozót egyszer inicializálják, a keresési feltétel határozza meg, hogy végre kell-e hajtani a ciklustörzset, és a frissítés minden iteráció után a hurokváltozó frissítésére vonatkozik.
- A hurokváltozó hatóköre a hurok törzsére korlátozódik, és a hurkon kívül nem érhető el.
- Bár a Golang csak a for ciklus konstrukciót biztosítja, emulálhatja a while és a do-while ciklus viselkedését a for ciklusok használatával.
- A for ciklus néhány egyéb alkalmazása magában foglalja a tömbök hurkolását és a függvényhívások elhalasztását a for ciklus törzsén belül.
Ezután tanulja meg a Python ciklusainak használatát. Jó tanulást!🎉
