Golang For Loop bemutatója [With Examples]

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.

  A szöveges parancsikonok használata a Google Dokumentumokban

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!

  Hogyan állítsuk le, hogy a Netflix automatikusan lejátssza a következő epizódot

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.

  Használja a Gesztusokat hívások kezdeményezésére, SMS küldésére, azonnali üzenetküldésre, e-mailek küldésére és egyebekre Androidon

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!🎉