Naučte se vše o smyčkách Golang for pomocí kódování několika užitečných příkladů.
Programovací jazyky jako Rust, Golang a TypeScript se v poslední době staly mezi vývojáři velmi populární. Pokud se zajímáte o back-endový vývoj a DevOps, měli byste zvážit, že učení Golang je vynikající volba!
Pokud jste začátečník, který si osvojil základy programovacího jazyka, smyčkové konstrukce jsou jedním z prvních konceptů, kterým byste měli porozumět.
Golang poskytuje pouze konstrukci cyklu for. A naučíme se o cyklech for a také o tom, jak emulovat další smyčky pomocí smyčky for.
Pojďme začít!
Table of Contents
Syntaxe Golang For Loop
V Golang můžete vytvořit smyčku for pomocí následující syntaxe:
for initialization; condition; update {
// do something
}
Tady,
- inicializace označuje inicializaci smyčkové proměnné.
- podmínka je podmínka smyčky, která určuje provedení těla smyčky. Dokud se podmínka opakování vyhodnotí jako pravdivá, příkazy v těle smyčky se provedou. A když se podmínka stane nepravdivou, ovládací prvek opustí smyčku.
- update označuje aktualizaci smyčkové proměnné – obvykle zvýšení nebo snížení.
💡 Všimněte si, jak je to podobné smyčce C for pouze bez závorek.
Zde je řídicí tok ve smyčkách Golang for:
Je čas kódovat nějaké příklady!⏰ Chcete-li kódovat, můžete buď použít místní instalaci Golang nebo spustit příklady na Go Playground.
Golang pro příklady smyčky
Použijme syntaxi, kterou jsme se právě naučili, abychom napsali naši první smyčku for. Zde je jednoduchá smyčka for, která vytiskne čísla 1 až 5 v krocích po jedné.
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
fmt.Println(i)
}
}
Inicializujeme cyklickou proměnnou i na 1, nastavíme podmínku na i <= 5 a po každé iteraci zvýšíme cyklickou proměnnou o jednu. A tady je výstup:
//Output For loop: 1 2 3 4 5
Napíšeme další smyčku for. Tato smyčka začíná od 5 a odpočítává se do 1; pokračuje, dokud není cyklická proměnná větší nebo rovna 1. Takže cyklickou proměnnou po každé iteraci snižujeme o jednu.
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := num; i >= 1; i-- {
fmt.Println(i)
}
}
A dostaneme očekávaný výstup:
//Output For loop: 5 4 3 2 1
Jaký je rozsah opakující se proměnné?
Rozsah smyčkové proměnné je omezen na blok smyčky for a není přístupný mimo smyčku.
Abychom to ověřili, zkusme získat přístup k hodnotě smyčkové proměnné i mimo smyčku:
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
fmt.Println(i)
}
fmt.Println(i)
}
Jak se očekávalo, narazíme na chybu, která uvádí, že i je nedefinované (a jeho rozsah je omezen na cyklus for):
// Output ./prog.go:11:14: undefined: i
Infinite For Loop v Golangu
Můžeme mít v Go nekonečné smyčky for? Ano, určitě můžeme!
Pokud se podíváte na tok řízení smyčky for:
- Tělo smyčky bude pokračovat v provádění, dokud se podmínka vyhodnotí jako pravdivá.
- Když se podmínka stane nepravdivou, ovládací prvek opustí smyčku.
- Pokud se tedy podmínka nikdy nestane nepravdivou (nebo je vždy pravdivá), máme nekonečnou smyčku.
Ale můžete také použít cyklus for bez inicializace, podmínky a aktualizace – aniž byste narazili na chyby syntaxe. Pokud tedy dokážete, aby smyčka běžela donekonečna i pomocí konstrukce smyčky for, jako je tato:
package main
import "fmt"
func main() {
for {
fmt.Println("running...")
}
}
//Output running... running... running... running... running... //and it goes on forever!
V tomto příkladu nastavíme proměnnou num na 5. A podmínka opakování je num >= 5. Cyklus tedy běží tak dlouho, dokud je num větší nebo rovno nule.
package main
import "fmt"
func main() {
num := 5
for num > 0 {
fmt.Println(num)
}
}
Protože se hodnota num nikdy nemění, podmínka se vždy vyhodnotí jako true a cyklus běží navždy!
//Output 5 5 5 5 5 5 //and it goes on forever!
Všechny Golangy mají pouze konstrukci cyklu for, můžeme se pokusit emulovat smyčky while a do-while pomocí smyček for. Pojďme se tedy naučit, jak na to!
Emulace while Loop pomocí For Loop
Smyčka while má obecně následující podobu:
// initialize looping var
while (condition){
// do something
// update looping var
}
Pokud si vzpomínáte, v prvním nekonečném cyklu for jsme napsali: použili jsme následující cyklus for – bez inicializace, podmínky a aktualizace.
for {
// the simplest infinite loop
}
Můžeme tedy upravit cyklus for tak, aby obsahoval pouze podmínku (v následujícím tvaru) pro emulaci cyklu while:
//initialize looping var
for condition {
// do something
// update looping var
}
Zde je ekvivalent cyklu while prvního cyklu for, který jsme napsali:
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
Emulace Do-While Loop pomocí For Loop
Pokud jste kódovali v jazyce jako C, víte, že konstrukce cyklu do-while má následující podobu:
// initialize looping var
do {
//something
// update looping var
} while(condition);
Klíčový rozdíl mezi smyčkou while a do while je v tom, že smyčka while kontroluje stav při vstupu do smyčky. Smyčka do-while na druhé straně kontroluje podmínku při výstupu ze smyčky.
Pokud se tedy ve smyčce while podmínka vyhodnotí jako nepravda, tělo smyčky se nikdy nespustí. V cyklu do-while se však tělo smyčky provede, i když se podmínka vyhodnotí jako nepravda.
Pomocí těchto informací můžeme emulovat chování smyčky do-while:
- Napište nekonečnou smyčku for
- Použijte podmíněný příkaz if se správnou podmínkou, abyste se dostali ze smyčky
Řekněme, že chcete napsat smyčku do-while, kde podmínka pro provedení těla smyčky je num < 0. Takže můžete napsat smyčku for a opustit smyčku, pokud 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
}
}
}
💡 Všimněte si, že provedení smyčky, pokud num < 0 a vyřazení ze smyčky, pokud num >= 0, jsou ekvivalentní podmínky.
Ačkoli je podmínka num > 0 zpočátku nepravdivá (num je 5), tělo smyčky se spustí jednou a emuluje smyčku do-while.
//Output Emulating do-while loop loop runs...
Smyčka přes pole pomocí pro smyčku
Při procházení polí v Golang pomocí smyčky for a rozsahu můžete přistupovat jak k indexům, tak k prvkům. Funguje to podobně jako funkce enumerate v Pythonu.
Zde vytvoříme numArray, pole celých čísel. A projděte to pomocí smyčky for:
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)
}
}
Jak je vidět, jsme schopni přistupovat k indexu i prvku na každém indexu současně:
//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
Použití odložení v Golang For Loop
V Golangu můžete použít klíčové slovo odložit k odložení volání funkcí.
Přestože se používá v aplikacích, jako je čištění zdrojů a zpracování chyb, může být užitečné pochopit, jak používat odložení uvnitř smyčky for. Podívejme se, co se stane, když použijeme defer uvnitř cyklu for k odložení volání funkce Println().
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
defer fmt.Println(i)
}
}
💬 Když je volání funkce odloženo, je volání funkce posunuto do zásobníku a je provedeno v pořadí LIFO. K tomuto provedení dojde až poté, co se vrátí funkce, která obklopuje příkaz odložit.
Takže fmt.Println(5) se provede jako první a fmt.Println(1) se provede jako poslední:
//Output For loop: 5 4 3 2 1
Závěr
Zde je shrnutí toho, co jste se v tomto tutoriálu naučili:
- V Golangu můžete vytvářet smyčky for se syntaxí: pro inicializaci; stav; update { //loop body}.
- Řídicí tok smyčky for je poměrně jednoduchý. Cyklovací proměnná je inicializována jednou, vyhledávací podmínka určuje, zda se má nebo nemá provést tělo smyčky, a aktualizace odkazuje na aktualizaci cyklické proměnné po každé iteraci.
- Rozsah smyčkové proměnné je omezen na tělo smyčky a není přístupný mimo smyčku.
- Ačkoli Golang poskytuje pouze konstrukci smyčky for, můžete emulovat chování smyčky while a do-while pomocí smyček for.
- Několik dalších aplikací smyčky for zahrnuje smyčkování přes pole a odkládání volání funkcí uvnitř těla smyčky for.
Dále se naučte, jak používat pro smyčky v Pythonu. Příjemné učení! 🎉