Μάθετε τα πάντα για τους βρόχους Golang κωδικοποιώντας πολλά χρήσιμα παραδείγματα.
Πρόσφατα, γλώσσες προγραμματισμού όπως οι Rust, Golang και TypeScript έχουν γίνει εξαιρετικά δημοφιλείς μεταξύ των προγραμματιστών. Αν σας ενδιαφέρει η ανάπτυξη back-end και τα DevOps, θα πρέπει να σκεφτείτε ότι το Golang είναι μια εξαιρετική επιλογή!
Εάν είστε αρχάριος και μαθαίνετε τις βασικές αρχές μιας γλώσσας προγραμματισμού, οι κατασκευές βρόχου είναι μία από τις πρώτες έννοιες που πρέπει να κατανοήσετε.
Το Golang παρέχει μόνο την κατασκευή βρόχου for. Και θα μάθουμε για τους βρόχους for και επίσης πώς να μιμούνται άλλους βρόχους χρησιμοποιώντας τον βρόχο for.
Ας ξεκινήσουμε!
Πίνακας περιεχομένων
Σύνταξη του Golang For Loop
Στο Golang, μπορείτε να δημιουργήσετε βρόχο για χρησιμοποιώντας την ακόλουθη σύνταξη:
for initialization; condition; update {
// do something
}
Εδώ,
- αρχικοποίηση υποδηλώνει την προετοιμασία της μεταβλητής βρόχου.
- συνθήκη είναι η συνθήκη βρόχου που καθορίζει την εκτέλεση του σώματος του βρόχου. Εφόσον η συνθήκη βρόχου αξιολογείται ως αληθής, οι εντολές στο σώμα του βρόχου εκτελούνται. Και όταν η συνθήκη γίνει ψευδής, το στοιχείο ελέγχου εξέρχεται από τον βρόχο.
- Η ενημέρωση υποδηλώνει την ενημέρωση της μεταβλητής βρόχου—συνήθως μια αύξηση ή μια μείωση.
💡 Παρατηρήστε πώς είναι παρόμοιο με τον βρόχο C for μόνο χωρίς τις παρενθέσεις.
Ακολουθεί η ροή ελέγχου στο Golang για βρόχους:
Ώρα να κωδικοποιήσουμε μερικά παραδείγματα!⏰ Για να κωδικοποιήσετε μαζί, μπορείτε είτε να χρησιμοποιήσετε μια τοπική εγκατάσταση του Golang είτε να εκτελέσετε τα παραδείγματα στο Go Playground.
Παραδείγματα Golang For Loop
Ας χρησιμοποιήσουμε τη σύνταξη που μόλις μάθαμε για να γράφουμε τον πρώτο μας βρόχο for. Εδώ είναι ένας απλός βρόχος for που εκτυπώνει τους αριθμούς 1 έως 5 σε βήματα του ενός.
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
fmt.Println(i)
}
}
Αρχικοποιούμε τη μεταβλητή βρόχου i σε 1, ορίζουμε τη συνθήκη σε i <= 5 και αυξάνουμε τη μεταβλητή βρόχου κατά ένα μετά από κάθε επανάληψη. Και εδώ είναι η έξοδος:
//Output For loop: 1 2 3 4 5
Ας γράψουμε έναν άλλο βρόχο for. Αυτός ο βρόχος ξεκινά από το 5 και μετρά αντίστροφα μέχρι το 1. συνεχίζεται έως ότου η μεταβλητή βρόχου είναι μεγαλύτερη ή ίση με 1. Έτσι μειώνουμε τη μεταβλητή βρόχου κατά ένα μετά από κάθε επανάληψη.
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := num; i >= 1; i-- {
fmt.Println(i)
}
}
Και παίρνουμε το αναμενόμενο αποτέλεσμα:
//Output For loop: 5 4 3 2 1
Ποιο είναι το πεδίο εφαρμογής της μεταβλητής βρόχου;
Το εύρος της μεταβλητής βρόχου περιορίζεται στο μπλοκ βρόχου for και δεν είναι προσβάσιμο εκτός του βρόχου.
Για να το επαληθεύσουμε αυτό, ας προσπαθήσουμε να αποκτήσουμε πρόσβαση στην τιμή της μεταβλητής βρόχου i εκτός του βρόχου:
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
fmt.Println(i)
}
fmt.Println(i)
}
Όπως αναμενόταν, συναντάμε ένα σφάλμα που δηλώνει ότι το i είναι απροσδιόριστο (και το εύρος του περιορίζεται στον βρόχο for):
// Output ./prog.go:11:14: undefined: i
Infinite For Loop στο Golang
Μπορούμε να έχουμε άπειρους βρόχους for στο Go; Ναι, σίγουρα μπορούμε!
Αν κοιτάξετε τη ροή ελέγχου του βρόχου for:
- Το σώμα του βρόχου θα συνεχίσει να εκτελείται όσο η συνθήκη αξιολογηθεί ως true.
- Όταν η συνθήκη γίνει ψευδής, το στοιχείο ελέγχου εξέρχεται από τον βρόχο.
- Έτσι, εάν η συνθήκη δεν γίνει ποτέ ψευδής (ή είναι πάντα αληθής), έχουμε έναν άπειρο βρόχο.
Αλλά μπορείτε επίσης να χρησιμοποιήσετε τον βρόχο for χωρίς την προετοιμασία, τη συνθήκη και την ενημέρωση — χωρίς να αντιμετωπίζετε σφάλματα σύνταξης. Έτσι, αν μπορείτε να κάνετε τον βρόχο να τρέχει άπειρα, ακόμη και χρησιμοποιώντας μια κατασκευή βρόχου for όπως αυτή:
package main
import "fmt"
func main() {
for {
fmt.Println("running...")
}
}
//Output running... running... running... running... running... //and it goes on forever!
Σε αυτό το παράδειγμα, ορίσαμε τη μεταβλητή num σε 5. Και η συνθήκη βρόχου είναι num >= 5. Άρα ο βρόχος εκτελείται εφόσον το num είναι μεγαλύτερο ή ίσο με μηδέν.
package main
import "fmt"
func main() {
num := 5
for num > 0 {
fmt.Println(num)
}
}
Επειδή η τιμή του num δεν αλλάζει ποτέ, η συνθήκη αξιολογείται πάντα ως true και ο βρόχος εκτελείται για πάντα!
//Output 5 5 5 5 5 5 //and it goes on forever!
Όλα τα Golang έχουν μόνο την κατασκευή βρόχου for, μπορούμε να προσπαθήσουμε να μιμηθούν τους βρόχους while και do-while χρησιμοποιώντας βρόχους for. Ας μάθουμε λοιπόν πώς να το κάνουμε!
Εξομοίωση while Loop με χρήση For Loop
Ο βρόχος while έχει γενικά την ακόλουθη μορφή:
// initialize looping var
while (condition){
// do something
// update looping var
}
Αν θυμάστε, στον πρώτο βρόχο για άπειρο γράψαμε: χρησιμοποιήσαμε τα ακόλουθα για βρόχο—χωρίς αρχικοποίηση, συνθήκη και ενημέρωση.
for {
// the simplest infinite loop
}
Μπορούμε λοιπόν να τροποποιήσουμε τον βρόχο for ώστε να περιέχει μόνο τη συνθήκη (στην ακόλουθη μορφή) για να μιμηθεί τον βρόχο while:
//initialize looping var
for condition {
// do something
// update looping var
}
Εδώ είναι το ισοδύναμο βρόχου while του πρώτου βρόχου for που γράψαμε:
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 με χρήση For Loop
Εάν έχετε κωδικοποιήσει σε μια γλώσσα όπως η C, γνωρίζετε ότι η κατασκευή του βρόχου do-while έχει την ακόλουθη μορφή:
// initialize looping var
do {
//something
// update looping var
} while(condition);
Η βασική διαφορά μεταξύ του while και του do while είναι ότι ο βρόχος while ελέγχει την κατάσταση κατά την είσοδο στον βρόχο. Ο βρόχος do-while, από την άλλη πλευρά, ελέγχει την κατάσταση κατά την έξοδο από τον βρόχο.
Έτσι, σε ένα βρόχο while, εάν η συνθήκη αξιολογηθεί ως ψευδής, το σώμα του βρόχου δεν εκτελείται ποτέ. Ωστόσο, σε έναν βρόχο do-while, το σώμα του βρόχου εκτελείται ακόμα κι αν η συνθήκη αξιολογηθεί ως ψευδής.
Χρησιμοποιώντας αυτές τις πληροφορίες, μπορούμε να προσομοιώσουμε τη συμπεριφορά ενός βρόχου do-while:
- Γράψτε έναν βρόχο άπειρο for
- Χρησιμοποιήστε μια εντολή if υπό όρους με τη σωστή συνθήκη για να βγείτε από τον βρόχο
Ας υποθέσουμε ότι θέλετε να γράψετε έναν βρόχο do-while όπου η συνθήκη για την εκτέλεση του σώματος του βρόχου είναι num < 0. Έτσι, μπορείτε να γράψετε έναν βρόχο for και να βγείτε από τον βρόχο εάν 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
}
}
}
💡 Σημειώστε ότι η εκτέλεση του βρόχου εάν num < 0 και η έξοδος από τον βρόχο εάν num >= 0 είναι ισοδύναμες συνθήκες.
Αν και η συνθήκη num > 0 είναι αρχικά ψευδής (το num είναι 5), το σώμα του βρόχου εκτελείται μία φορά, μιμούμενος έναν βρόχο do-while.
//Output Emulating do-while loop loop runs...
Επανάληψη βρόχου μέσω πινάκων με χρήση βρόχου For
Όταν κάνετε βρόχο μεταξύ πινάκων στο Golang χρησιμοποιώντας βρόχο for και εύρος, μπορείτε να έχετε πρόσβαση τόσο στους δείκτες όσο και στα στοιχεία. Αυτό λειτουργεί παρόμοια με τη συνάρτηση enumerate στην Python.
Εδώ, δημιουργούμε το numArray, έναν πίνακα ακεραίων. Και πραγματοποιήστε βρόχο μέσω του χρησιμοποιώντας έναν βρόχο 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)
}
}
Όπως φαίνεται, μπορούμε να έχουμε πρόσβαση τόσο στο ευρετήριο όσο και στο στοιχείο σε κάθε ευρετήριο ταυτόχρονα:
//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
Χρήση αναβολής στο Golang For Loop
Στο Golang, μπορείτε να χρησιμοποιήσετε τη λέξη-κλειδί αναβολή για να αναβάλετε τις κλήσεις συναρτήσεων.
Αν και χρησιμοποιείται σε εφαρμογές όπως η εκκαθάριση πόρων και ο χειρισμός σφαλμάτων, μπορεί να είναι χρήσιμο να κατανοήσετε πώς να χρησιμοποιείτε το defer μέσα σε έναν βρόχο for. Ας δούμε τι συμβαίνει όταν χρησιμοποιούμε defer μέσα στον βρόχο for για να αναβάλουμε τις κλήσεις στη συνάρτηση Println().
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
defer fmt.Println(i)
}
}
💬 Όταν μια κλήση συνάρτησης αναβάλλεται, η κλήση συνάρτησης ωθείται στη στοίβα και εκτελείται με σειρά LIFO. Αυτή η εκτέλεση πραγματοποιείται μόνο αφού επιστρέψει η συνάρτηση που περιβάλλει τη δήλωση αναβολής.
Έτσι, η fmt.Println(5) εκτελείται πρώτα και η fmt.Println(1) εκτελείται τελευταία:
//Output For loop: 5 4 3 2 1
συμπέρασμα
Ακολουθεί μια περίληψη των όσων μάθατε σε αυτό το σεμινάριο:
- Στο Golang, μπορείτε να δημιουργήσετε βρόχους για με τη σύνταξη: για αρχικοποίηση; κατάσταση; ενημέρωση {//loop body}.
- Η ροή ελέγχου του βρόχου for είναι αρκετά απλή. Η μεταβλητή βρόχου αρχικοποιείται μία φορά, η συνθήκη αναζήτησης καθορίζει εάν θα εκτελεστεί ή όχι το σώμα του βρόχου και η ενημέρωση αναφέρεται στην ενημέρωση της μεταβλητής βρόχου μετά από κάθε επανάληψη.
- Το εύρος της μεταβλητής βρόχου περιορίζεται στο σώμα του βρόχου και δεν είναι προσβάσιμο εκτός του βρόχου.
- Αν και το Golang παρέχει μόνο την κατασκευή βρόχου for, μπορείτε να μιμηθείτε τις συμπεριφορές βρόχου while και do-while χρησιμοποιώντας βρόχους for.
- Μερικές άλλες εφαρμογές του βρόχου for περιλαμβάνουν τον βρόχο μέσω πινάκων και την αναβολή κλήσεων συναρτήσεων μέσα στο σώμα του βρόχου for.
Στη συνέχεια, μάθετε πώς να χρησιμοποιείτε βρόχους for στην Python. Καλή μάθηση!🎉