Otkrijte sve tajne Go programskog jezika vezane za petlje, prolazeći kroz praktične primere kodiranja.
U poslednje vreme, jezici poput Rust-a, Go-a i TypeScript-a stekli su ogromnu popularnost među programerima. Ako vas zanima razvoj backend-a i DevOps, Go je odličan izbor za učenje!
Za početnike koji savladavaju osnove programiranja, petlje su među ključnim konceptima koje je neophodno razumeti.
Go pruža samo jednu vrstu petlje, a to je `for` petlja. Naučićemo kako se ona koristi, ali i kako pomoću nje simulirati druge tipove petlji.
Krenimo!
Sintaksa Go `for` petlje
U Go-u, `for` petlja se kreira na sledeći način:
for inicijalizacija; uslov; ažuriranje {
// kod koji se izvršava
}
Gde:
- inicijalizacija definiše početnu vrednost promenljive petlje.
- uslov je logički izraz koji određuje da li će se telo petlje izvršavati. Sve dok je uslov `true`, naredbe unutar petlje se izvršavaju. Kada uslov postane `false`, petlja se prekida.
- ažuriranje vrši izmenu vrednosti promenljive petlje – najčešće se radi o inkrementiranju ili dekrementiranju.
💡 Obratite pažnju kako je sintaksa slična C `for` petlji, samo bez zagrada.
Evo kako teče kontrola u Go `for` petlji:
Vreme je za kodiranje! ⏰ Možete koristiti lokalnu Go instalaciju ili isprobati primere na Go Playground-u.
Primjeri Go `for` petlji
Iskoristimo novostečeno znanje sintakse da napišemo našu prvu `for` petlju. Ovo je jednostavna petlja koja ispisuje brojeve od 1 do 5, korakom od 1.
package main
import "fmt"
func main() {
fmt.Println("For petlja:")
num := 5
for i := 1; i <= num; i++ {
fmt.Println(i)
}
}
Promenljiva petlje `i` se inicijalizuje na 1, uslov je `i <= 5`, a nakon svake iteracije se `i` uvećava za 1. Rezultat je:
//Izlaz For petlja: 1 2 3 4 5
Napišimo još jednu `for` petlju. Ova petlja kreće od 5 i odbrojava do 1, nastavljajući izvršavanje sve dok je promenljiva petlje veća ili jednaka 1. Promenljiva petlje se smanjuje za jedan u svakoj iteraciji.
package main
import "fmt"
func main() {
fmt.Println("For petlja:")
num := 5
for i := num; i >= 1; i-- {
fmt.Println(i)
}
}
I očekivani izlaz je:
//Izlaz For petlja: 5 4 3 2 1
Koja je oblast važenja promenljive petlje?
Oblast važenja promenljive petlje ograničena je na blok `for` petlje i nije dostupna izvan nje.
Da bismo to proverili, pokušaćemo da pristupimo vrednosti promenljive petlje i izvan petlje:
package main
import "fmt"
func main() {
fmt.Println("For petlja:")
num := 5
for i := 1; i <= num; i++ {
fmt.Println(i)
}
fmt.Println(i)
}
Kao što se i očekuje, dobijamo grešku da `i` nije definisano (njena oblast važenja je ograničena na `for` petlju):
// Izlaz ./prog.go:11:14: undefined: i
Beskonačna `for` petlja u Go-u
Da li je moguće imati beskonačne `for` petlje u Go-u? Da, svakako!
Ako pogledamo kontrolni tok `for` petlje:
- Telo petlje će se nastaviti izvršavati dok je uslov `true`.
- Kada uslov postane `false`, petlja se zaustavlja.
- Dakle, ako uslov nikada ne postane `false` (ili je uvek `true`), imamo beskonačnu petlju.
Takođe možete koristiti `for` petlju bez inicijalizacije, uslova i ažuriranja – bez grešaka sintakse. Dakle, moguće je napraviti beskonačnu petlju koristeći `for` strukturu poput ove:
package main
import "fmt"
func main() {
for {
fmt.Println("Izvrsava se...")
}
}
//Izlaz Izvrsava se... Izvrsava se... Izvrsava se... Izvrsava se... Izvrsava se... //i tako u nedogled!
U ovom primeru, promenljiva `num` je postavljena na 5. Uslov petlje je `num >= 5`. Zato petlja traje sve dok je `num` veće ili jednako nuli.
package main
import "fmt"
func main() {
num := 5
for num > 0 {
fmt.Println(num)
}
}
Pošto se vrednost `num` nikada ne menja, uslov je uvek `true`, i petlja se izvršava beskonačno!
//Izlaz 5 5 5 5 5 5 //i tako u nedogled!
Pošto Go ima samo `for` petlju, možemo pokušati da simuliramo `while` i `do-while` petlje koristeći `for` petlje. Hajde da vidimo kako to možemo uraditi!
Simuliranje `while` petlje pomoću `for` petlje
`While` petlja generalno ima sledeći oblik:
// inicijalizacija promenljive petlje
while (uslov){
// kod koji se izvršava
// ažuriranje promenljive petlje
}
Ako se sećate, u primeru beskonačne `for` petlje, koristili smo `for` petlju bez inicijalizacije, uslova i ažuriranja:
for {
// najjednostavnija beskonačna petlja
}
Možemo izmeniti `for` petlju da sadrži samo uslov (u sledećem obliku) da simuliramo `while` petlju:
//inicijalizacija promenljive petlje
for uslov {
// kod koji se izvršava
// ažuriranje promenljive petlje
}
Evo ekvivalenta `while` petlje prvoj `for` petlji koju smo napisali:
package main
import "fmt"
func main() {
fmt.Println("Simulacija while petlje")
num := 5
for num > 0 {
fmt.Println(num)
num--
}
}
//Izlaz Simulacija while petlje 5 4 3 2 1
Simuliranje `do-while` petlje pomoću `for` petlje
Ako ste programirali u jeziku kao što je C, znate da `do-while` petlja ima sledeći oblik:
// inicijalizacija promenljive petlje
do {
//kod koji se izvršava
// ažuriranje promenljive petlje
} while(uslov);
Glavna razlika između `while` i `do-while` petlje je u tome što `while` petlja proverava uslov na početku, pre ulaska u petlju. `Do-while` petlja, s druge strane, proverava uslov nakon izvršavanja tela petlje.
Dakle, kod `while` petlje, ako je uslov `false`, telo petlje se nikada ne izvršava. Međutim, kod `do-while` petlje, telo petlje se izvršava makar jednom, čak i ako je uslov `false`.
Koristeći ovu informaciju, možemo simulirati `do-while` petlju:
- Napišite beskonačnu `for` petlju.
- Koristite `if` sa odgovarajućim uslovom da izađete iz petlje.
Pretpostavimo da želite da napišete `do-while` petlju gde se telo petlje izvršava ako je `num` < 0. Možete napisati `for` petlju i prekinuti izvršavanje ako je `num` >= 0.
package main
import "fmt"
func main() {
fmt.Println("Simulacija do-while petlje")
num := 5
for {
fmt.Println("Petlja se izvrsava...")
if num >= 0 {
break
}
}
}
💡 Važno je napomenuti da su uslovi: izvršavanje petlje ako je `num` < 0 i izlazak iz petlje ako je `num` >= 0, ekvivalentni uslovi.
Iako je uslov `num > 0` u početku `false` (jer je `num` = 5), telo petlje se izvršava jednom, simulirajući `do-while` petlju.
//Izlaz Simulacija do-while petlje Petlja se izvrsava...
Petlja kroz nizove pomoću `for` petlje
Kada prolazite kroz nizove u Go-u pomoću `for` petlje i `range`, možete pristupiti i indeksima i elementima. Slično je `enumerate` funkciji u Python-u.
Kreiramo `numArray`, niz celih brojeva, i prolazimo kroz njega pomoću `for` petlje:
package main
import "fmt"
func main() {
fmt.Println("Prolazak kroz niz")
numArray := []int{3, 7, 0, 10, 8, 9}
for idx, num := range numArray {
fmt.Println("Na indeksu", idx, ": ", num)
}
}
Kao što vidite, možemo istovremeno pristupiti indeksu i elementu u svakom indeksu:
//Izlaz Prolazak kroz niz Na indeksu 0 : 3 Na indeksu 1 : 7 Na indeksu 2 : 0 Na indeksu 3 : 10 Na indeksu 4 : 8 Na indeksu 5 : 9
Upotreba `defer` u Go `for` petlji
U Go-u, možete koristiti ključnu reč `defer` da odložite izvršavanje funkcija.
Iako se najčešće koristi za čišćenje resursa i obradu grešaka, korisno je razumeti kako se `defer` koristi unutar `for` petlje. Pogledajmo šta se dešava kada koristimo `defer` unutar `for` petlje za odlaganje poziva funkcije `Println()`.
package main
import "fmt"
func main() {
fmt.Println("For petlja:")
num := 5
for i := 1; i <= num; i++ {
defer fmt.Println(i)
}
}
💬 Kada se poziv funkcije odloži, gura se na stek i izvršava u LIFO (poslednji ušao, prvi izašao) redosledu. Ovo izvršavanje se dešava tek nakon što se završi funkcija koja sadrži `defer` naredbu.
Dakle, `fmt.Println(5)` se izvršava prvi, a `fmt.Println(1)` se izvršava poslednji:
//Izlaz For petlja: 5 4 3 2 1
Zaključak
Evo sažetka onoga što ste naučili u ovom vodiču:
- U Go-u, `for` petlje se kreiraju sa sintaksom: `for inicijalizacija; uslov; ažuriranje { //telo petlje }`.
- Kontrolni tok `for` petlje je prilično jednostavan. Promenljiva petlje se inicijalizuje jednom, uslov određuje da li će se telo petlje izvršiti, a ažuriranje se odnosi na promenu promenljive petlje nakon svake iteracije.
- Oblast važenja promenljive petlje ograničena je na telo petlje i nije dostupna izvan nje.
- Iako Go pruža samo `for` petlju, možete simulirati ponašanje `while` i `do-while` petlji koristeći `for` petlje.
- Neke druge primene `for` petlje uključuju prolazak kroz nizove i odlaganje poziva funkcija unutar tela `for` petlje.
Sledeće, naučite kako se koriste `for` petlje u Python-u. Srećno učenje! 🎉