Aflați totul despre Golang pentru bucle prin codificarea mai multor exemple utile.
Recent, limbaje de programare precum Rust, Golang și TypeScript au devenit super populare în rândul dezvoltatorilor. Dacă sunteți interesat de dezvoltarea back-end și DevOps, ar trebui să vă gândiți să învățați Golang este o opțiune excelentă!
Dacă sunteți un începător care învață bazele unui limbaj de programare, constructele bucle sunt unul dintre primele concepte pe care ar trebui să le înțelegeți.
Golang oferă numai construcția buclei for. Și vom învăța despre buclele for și, de asemenea, cum să emulăm alte bucle folosind bucla for.
Sa incepem!
Cuprins
Sintaxa lui Golang For Loop
În Golang, puteți crea bucla for folosind următoarea sintaxă:
for initialization; condition; update {
// do something
}
Aici,
- inițializarea denotă inițializarea variabilei de buclă.
- condiția este condiția de buclă care determină execuția corpului buclei. Atâta timp cât condiția de buclă se evaluează la adevărat, instrucțiunile din corpul buclei sunt executate. Și când condiția devine falsă, controlul iese din buclă.
- update denotă actualizarea variabilei în buclă — de obicei o creștere sau o scădere.
💡 Observați cum este similar cu bucla C for numai fără paranteze.
Iată fluxul de control în Golang pentru bucle:
Este timpul să codificați câteva exemple!⏰ Pentru a codifica, puteți fie să utilizați o instalare locală a Golang, fie să rulați exemplele pe Go Playground.
Golang For Exemple de buclă
Să folosim sintaxa pe care tocmai am învățat să scriem prima buclă for. Iată o buclă simplă pentru care tipărește numerele de la 1 la 5 în pași de unu.
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
fmt.Println(i)
}
}
Inițializam variabila de buclă i la 1, setăm condiția la i <= 5 și incrementăm variabila de buclă cu una după fiecare iterație. Și iată rezultatul:
//Output For loop: 1 2 3 4 5
Să scriem o altă buclă for. Această buclă începe de la 5 și numără invers până la 1; aceasta continuă până când variabila de buclă este mai mare sau egală cu 1. Deci decrementăm variabila de buclă cu una după fiecare iterație.
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := num; i >= 1; i-- {
fmt.Println(i)
}
}
Și obținem rezultatul așteptat:
//Output For loop: 5 4 3 2 1
Care este domeniul de aplicare al variabilei de buclă?
Domeniul de aplicare al variabilei de buclă este limitat la blocul de buclă for și nu este accesibil în afara buclei.
Pentru a verifica acest lucru, să încercăm să accesăm valoarea variabilei de buclă i în afara buclei:
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
fmt.Println(i)
}
fmt.Println(i)
}
După cum era de așteptat, ne confruntăm cu o eroare care afirmă că i este un nedefinit (și domeniul său de aplicare este limitat la bucla for):
// Output ./prog.go:11:14: undefined: i
Bucla infinită pentru în Golang
Putem avea bucle for infinite în Go? Da, cu siguranță putem!
Dacă te uiți la fluxul de control al buclei for:
- Corpul buclei va continua să se execute atâta timp cât condiția se evaluează la adevărat.
- Când condiția devine falsă, controlul iese din buclă.
- Deci, dacă condiția nu devine niciodată falsă (sau este întotdeauna adevărată), avem o buclă infinită.
Dar puteți utiliza și bucla for fără inițializare, condiție și actualizare, fără a avea erori de sintaxă. Deci, dacă puteți face bucla să ruleze la infinit chiar și folosind o construcție de buclă for ca aceasta:
package main
import "fmt"
func main() {
for {
fmt.Println("running...")
}
}
//Output running... running... running... running... running... //and it goes on forever!
În acest exemplu, setăm variabila num la 5. Și condiția de buclă este num >= 5. Deci, bucla rulează atâta timp cât num este mai mare sau egal cu zero.
package main
import "fmt"
func main() {
num := 5
for num > 0 {
fmt.Println(num)
}
}
Deoarece valoarea lui num nu se schimbă niciodată, condiția se evaluează întotdeauna la adevărat, iar bucla rulează pentru totdeauna!
//Output 5 5 5 5 5 5 //and it goes on forever!
Toate Golang au doar construcția buclei for, putem încerca să emulăm buclele while și do-while folosind buclele for. Deci hai să învățăm cum să o facem!
Emularea While Loop folosind For Loop
Bucla while ia, în general, următoarea formă:
// initialize looping var
while (condition){
// do something
// update looping var
}
Dacă vă amintiți, în prima buclă infinită pentru am scris: am folosit următoarele bucle for – fără inițializare, condiție și actualizare.
for {
// the simplest infinite loop
}
Deci, putem modifica bucla for pentru a conține doar condiția (în următoarea formă) pentru a emula bucla while:
//initialize looping var
for condition {
// do something
// update looping var
}
Iată echivalentul buclei while al primei bucle for pe care am scris-o:
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
Emularea Do-While Loop folosind For Loop
Dacă ați codat într-un limbaj precum C, știți că construcția buclei do-while ia următoarea formă:
// initialize looping var
do {
//something
// update looping var
} while(condition);
Diferența cheie dintre bucla while și do while este că bucla while verifică condiția la intrarea în buclă. Pe de altă parte, bucla do-while verifică starea la ieșirea din buclă.
Deci, într-o buclă while, dacă condiția este evaluată la fals, corpul buclei nu se execută niciodată. Cu toate acestea, într-o buclă do-while, corpul buclei se execută chiar dacă condiția este evaluată ca falsă.
Folosind aceste informații, putem emula comportamentul unei bucle do-while:
- Scrieți o buclă for infinită
- Utilizați o instrucțiune condițională if cu condiția corectă pentru a ieși din buclă
Să presupunem că doriți să scrieți o buclă do-while în care condiția pentru ca corpul buclei să se execute este num < 0. Deci puteți scrie o buclă for și puteți ieși din buclă dacă 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
}
}
}
💡 Rețineți că executarea buclei dacă num < 0 și ieșirea din buclă dacă num >= 0 sunt condiții echivalente.
Deși condiția num > 0 este inițial falsă (num este 5), corpul buclei rulează o dată, emulând o buclă do-while.
//Output Emulating do-while loop loop runs...
Buclă prin matrice folosind For Loop
Când treceți în buclă prin matrice în Golang folosind o buclă for și un interval, puteți accesa atât indici, cât și elemente. Aceasta funcționează în mod similar cu funcția de enumerare din Python.
Aici, creăm numArray, o matrice de numere întregi. Și treceți prin el folosind o buclă 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)
}
}
După cum s-a văzut, putem accesa atât indexul, cât și elementul de la fiecare index simultan:
//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
Folosind defer în Golang For Loop
În Golang, puteți utiliza cuvântul cheie defer pentru a amâna apelurile de funcții.
Deși este utilizat în aplicații precum curățarea resurselor și gestionarea erorilor, poate fi util să înțelegeți cum să utilizați defer în interiorul unei bucle for. Să vedem ce se întâmplă când folosim defer în bucla for pentru a amâna apelurile către funcția Println().
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
defer fmt.Println(i)
}
}
💬 Când un apel de funcție este amânat, apelul de funcție este împins în stivă și este executat în ordinea LIFO. Această execuție are loc numai după ce funcția care înconjoară instrucțiunea defer revine.
Deci fmt.Println(5) este executat primul și fmt.Println(1) este executat ultimul:
//Output For loop: 5 4 3 2 1
Concluzie
Iată un rezumat a ceea ce ați învățat în acest tutorial:
- În Golang, puteți crea bucle for cu sintaxa: for initialization; condiție; actualizați { //corpul buclei}.
- Fluxul de control al buclei for este destul de simplu. Variabila de buclă este inițializată o dată, condiția de căutare determină dacă se execută sau nu corpul buclei, iar actualizarea se referă la actualizarea variabilei de buclă după fiecare iterație.
- Domeniul de aplicare al variabilei de buclă este limitat la corpul buclei și nu este accesibil în afara buclei.
- Deși Golang oferă doar construcția buclei for, puteți emula comportamentele buclei while și do-while folosind buclele for.
- Alte câteva aplicații ale buclei for includ bucla prin matrice și amânarea apelurilor de funcție în interiorul corpului buclei for.
Apoi, aflați cum să utilizați buclele for în Python. Învățare fericită!🎉