Dowiedz się wszystkiego o pętlach Golang for, kodując kilka przydatnych przykładów.
Ostatnio języki programowania, takie jak Rust, Golang i TypeScript, stały się bardzo popularne wśród programistów. Jeśli interesuje Cię back-end development i DevOps, powinieneś rozważyć naukę Golanga jako doskonałą opcję!
Jeśli dopiero zaczynasz poznawać podstawy języka programowania, konstrukcje pętli są jednym z pierwszych pojęć, które powinieneś zrozumieć.
Golang zapewnia tylko konstrukcję pętli for. Dowiemy się również o pętlach for, a także o tym, jak emulować inne pętle za pomocą pętli for.
Zaczynajmy!
Spis treści:
Składnia pętli Golang For
W Golang możesz utworzyć pętlę for, używając następującej składni:
for initialization; condition; update {
// do something
}
Tutaj,
- inicjalizacja oznacza inicjalizację zmiennej pętli.
- warunek jest warunkiem pętli, który określa wykonanie ciała pętli. Tak długo, jak warunek pętli ma wartość true, instrukcje w ciele pętli są wykonywane. A kiedy warunek staje się fałszywy, sterowanie opuszcza pętlę.
- aktualizacja oznacza aktualizację zmiennej pętli — zwykle przyrost lub spadek.
💡 Zauważ, że jest to podobne do pętli C for tylko bez nawiasów.
Oto przepływ sterowania w Golang dla pętli:
Czas na kodowanie kilku przykładów!⏰ Aby razem kodować, możesz użyć lokalnej instalacji Golanga lub uruchomić przykłady na Go Playground.
Przykłady pętli Golang For
Użyjmy składni, której właśnie się nauczyliśmy, aby napisać naszą pierwszą pętlę for. Oto prosta pętla for, która wypisuje liczby od 1 do 5 w krokach co jeden.
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
fmt.Println(i)
}
}
Inicjujemy zapętloną zmienną i na 1, ustawiamy warunek na i <= 5 i zwiększamy zapętloną zmienną o jeden po każdej iteracji. A oto wyjście:
//Output For loop: 1 2 3 4 5
Napiszmy kolejną pętlę for. Ta pętla zaczyna się od 5 i odlicza do 1; trwa to do momentu, gdy zmienna zapętlona będzie większa lub równa 1. Zatem zmniejszamy zmienną zapętloną o jeden po każdej iteracji.
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := num; i >= 1; i-- {
fmt.Println(i)
}
}
I otrzymujemy oczekiwany wynik:
//Output For loop: 5 4 3 2 1
Jaki jest zakres zmiennej pętli?
Zakres zmiennej pętli jest ograniczony do bloku pętli for i nie jest dostępny poza pętlą.
Aby to zweryfikować, spróbujmy uzyskać dostęp do wartości zapętlonej zmiennej i poza pętlą:
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
fmt.Println(i)
}
fmt.Println(i)
}
Zgodnie z oczekiwaniami napotkaliśmy błąd, który mówi, że i jest niezdefiniowane (a jego zakres jest ograniczony do pętli for):
// Output ./prog.go:11:14: undefined: i
Nieskończona pętla For w Golang
Czy możemy mieć nieskończone pętle for w Go? Tak, z pewnością możemy!
Jeśli spojrzysz na przepływ sterowania pętli for:
- Treść pętli będzie wykonywana tak długo, jak długo warunek będzie miał wartość true.
- Gdy warunek staje się fałszywy, formant opuszcza pętlę.
- Więc jeśli warunek nigdy nie staje się fałszywy (lub zawsze jest prawdziwy), mamy nieskończoną pętlę.
Ale możesz też użyć pętli for bez inicjalizacji, warunku i aktualizacji — bez popełniania błędów składniowych. Więc jeśli możesz sprawić, by pętla działała w nieskończoność, nawet używając konstrukcji pętli for takiej jak ta:
package main
import "fmt"
func main() {
for {
fmt.Println("running...")
}
}
//Output running... running... running... running... running... //and it goes on forever!
W tym przykładzie ustawiamy zmienną num na 5. Warunek pętli to num >= 5. Zatem pętla działa tak długo, jak długo num jest większe lub równe zeru.
package main
import "fmt"
func main() {
num := 5
for num > 0 {
fmt.Println(num)
}
}
Ponieważ wartość num nigdy się nie zmienia, warunek zawsze przyjmuje wartość true, a pętla działa w nieskończoność!
//Output 5 5 5 5 5 5 //and it goes on forever!
All Golang ma tylko konstrukcję pętli for, możemy spróbować naśladować pętle while i do-while za pomocą pętli for. Nauczmy się więc, jak to robić!
Emulowanie pętli while za pomocą pętli For
Pętla while zwykle przyjmuje następującą postać:
// initialize looping var
while (condition){
// do something
// update looping var
}
Jeśli pamiętasz, w pierwszej nieskończonej pętli for napisaliśmy: wykorzystaliśmy następującą pętlę for — bez inicjalizacji, warunku i aktualizacji.
for {
// the simplest infinite loop
}
Możemy więc zmodyfikować pętlę for, aby zawierała tylko warunek (w następującej formie) emulujący pętlę while:
//initialize looping var
for condition {
// do something
// update looping var
}
Oto odpowiednik pętli while pierwszej pętli for, którą napisaliśmy:
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
Emulowanie pętli Do-While za pomocą pętli For
Jeśli kodowałeś w języku takim jak C, wiesz, że konstrukcja pętli do-while ma następującą postać:
// initialize looping var
do {
//something
// update looping var
} while(condition);
Kluczowa różnica między pętlą while i do while polega na tym, że pętla while sprawdza warunek przy wejściu do pętli. Z drugiej strony pętla do-while sprawdza warunek po wyjściu z pętli.
Tak więc w pętli while, jeśli warunek ma wartość false, treść pętli nigdy się nie wykonuje. Jednak w pętli do-while treść pętli jest wykonywana, nawet jeśli warunek ma wartość false.
Korzystając z tych informacji, możemy naśladować zachowanie pętli do-while:
- Napisz nieskończoną pętlę for
- Użyj instrukcji warunkowej if z poprawnym warunkiem, aby wyrwać się z pętli
Powiedzmy, że chcesz napisać pętlę do-while, w której warunkiem wykonania treści pętli jest num < 0. Możesz więc napisać pętlę for i wyjść z pętli, jeśli 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
}
}
}
💡 Zauważ, że wykonanie pętli, jeśli num < 0 i przerwanie pętli, jeśli num >= 0, są warunkami równoważnymi.
Chociaż warunek num > 0 jest początkowo fałszywy (num wynosi 5), treść pętli jest wykonywana raz, emulując pętlę do-while.
//Output Emulating do-while loop loop runs...
Zapętlanie tablic za pomocą pętli For
Podczas zapętlania tablic w Golang przy użyciu pętli for i zakresu można uzyskać dostęp zarówno do indeksów, jak i elementów. Działa to podobnie do funkcji enumerate w Pythonie.
Tutaj tworzymy numArray, tablicę liczb całkowitych. I przejdź przez to za pomocą pętli 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 widać, jesteśmy w stanie jednocześnie uzyskać dostęp zarówno do indeksu, jak i elementu w każdym indeksie:
//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
Używanie odroczenia w Golang For Loop
W Golang możesz użyć słowa kluczowego defer, aby odroczyć wywołania funkcji.
Chociaż jest używany w aplikacjach takich jak czyszczenie zasobów i obsługa błędów, pomocne może być zrozumienie, jak używać odroczenia wewnątrz pętli for. Zobaczmy, co się stanie, gdy użyjemy defer wewnątrz pętli for, aby odroczyć wywołania funkcji Println().
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
defer fmt.Println(i)
}
}
💬 Kiedy wywołanie funkcji jest odroczone, wywołanie funkcji jest umieszczane na stosie i wykonywane w kolejności LIFO. To wykonanie ma miejsce dopiero po powrocie funkcji otaczającej instrukcję odroczenia.
Zatem fmt.Println(5) jest wykonywany jako pierwszy, a fmt.Println(1) jako ostatni:
//Output For loop: 5 4 3 2 1
Wniosek
Oto podsumowanie tego, czego nauczyłeś się w tym samouczku:
- W Golangu możesz tworzyć pętle for ze składnią: for initialization; stan : schorzenie; aktualizacja { //ciało pętli}.
- Przepływ sterowania w pętli for jest dość prosty. Zmienna zapętlona jest inicjowana raz, warunek wyszukiwania określa, czy wykonać treść pętli, a aktualizacja odnosi się do aktualizacji zapętlonej zmiennej po każdej iteracji.
- Zakres zmiennej pętli jest ograniczony do ciała pętli i nie jest dostępny poza pętlą.
- Chociaż Golang zapewnia tylko konstrukcję pętli for, możesz emulować zachowania pętli while i do-while za pomocą pętli for.
- Kilka innych zastosowań pętli for obejmuje przechodzenie przez tablice i odraczanie wywołań funkcji wewnątrz ciała pętli for.
Następnie naucz się używać pętli for w Pythonie. Miłej nauki!🎉