Το πιο σημαντικό, τα γενόσημα διατηρούν την ισχυρή ασφάλεια τύπου του Go, η οποία επιτρέπει τον έλεγχο στατικού τύπου κατά το χρόνο μεταγλώττισης και διασφαλίζει την ορθότητα του τύπου. Παρέχουν έναν τυποποιημένο χειρισμό σφαλμάτων εντός του γενικού κώδικα που βελτιώνει τη σαφήνεια και τη δυνατότητα συντήρησης. Επιπλέον, παρέχουν έναν τυποποιημένο χειρισμό σφαλμάτων εντός του γενικού κώδικα που βελτιώνει τη σαφήνεια και τη δυνατότητα συντήρησης. Σε αυτήν την ανάρτηση, θα εξετάσουμε πολλές εφαρμογές και παραδείγματα Go generic του πραγματικού κόσμου.
Παράδειγμα 1: Χρήση της Γενικής Συνάρτησης Golang
Μία από τις κύριες περιπτώσεις χρήσης για τα γενόσημα είναι η δημιουργία συναρτήσεων που μπορούν να λειτουργούν σε διαφορετικούς τύπους. Εδώ, πηγαίνουμε με ένα από τα παραδείγματα όπου χρησιμοποιείται η γενική συνάρτηση περιφέρειας.
πακέτο κύριος
εισαγωγή 'fmt'
func περιφέρεια [ r ενθ | float32 ]( ακτίνα r ) {
ντο := 3 * 2 * ακτίνα κύκλου
fmt . Println ( 'Η γενική περιφέρεια είναι:' , ντο )
}
func κύριος () {
ήταν r1 ενθ = 7
ήταν r2 float32 = 7 . 5
περιφέρεια ( r1 )
περιφέρεια ( r2 )
}
Στην αρχή του προηγούμενου κώδικα, η γραμμή εισάγει το πακέτο «fmt» που παρέχει λειτουργίες για μορφοποιημένη είσοδο/έξοδο, συμπεριλαμβανομένης της εκτύπωσης της εξόδου στην κονσόλα. Στη συνέχεια, ορίζουμε μια γενική συνάρτηση με το όνομα 'circumference' που παίρνει μια ακτίνα παραμέτρου ενός γενικού τύπου 'r' που μπορεί να είναι είτε 'int' ή 'float32'. Μέσα στη συνάρτηση, υπολογίζει την περιφέρεια πολλαπλασιάζοντας την ακτίνα με τη σταθερή τιμή «3» και στη συνέχεια πολλαπλασιάζοντας την επί «2». Τέλος, εκτυπώνει την υπολογισμένη περιφέρεια χρησιμοποιώντας το “fmt.Println”.
Στη συνέχεια, έχουμε την κύρια συνάρτηση όπου δύο μεταβλητές, r1 και r2, δηλώνονται και εκχωρούνται με τις τιμές 7 και 7,5, αντίστοιχα. Μετά από αυτό, η συνάρτηση 'circumference' καλείται δύο φορές, περνώντας τα r1 και r2 ως ορίσματα.
Η έξοδος εμφανίζει τον υπολογισμό εκτυπώνοντας τις περιφέρειες των κύκλων ως εξής:
Παράδειγμα 2: Χρήση της γενικής διεπαφής Golang
Επιπλέον, τα γενόσημα Golang μας βοηθούν με τις διεπαφές τους. Οι διεπαφές στο Go είναι ένα ζωτικό εργαλείο για τη διευκόλυνση της επαναχρησιμοποίησης του κώδικα και του πολυμορφισμού. Επιτρέποντάς τους να λειτουργούν με πολλούς τύπους, τα γενικά αυξάνουν την ισχύ των διεπαφών. Ακολουθεί ο πηγαίος κώδικας της διεπαφής γενικών Golang:
πακέτο κύριος
εισαγωγή 'fmt'
τύπος EmpAge διεπαφή {
int64 | int32 | float32 | float64
}
func newGenericFunc [ ηλικία Ηλικία ]( emp_Age ηλικία ) {
val := ενθ ( emp_Age ) + 1
fmt . Println ( val )
}
func κύριος () {
fmt . Println ( «Η εποχή των εργαζομένων» )
ήταν Ηλικία 1 int64 = 24
ήταν Ηλικία 2 float64 = 25 . 5
newGenericFunc ( Ηλικία 1 )
newGenericFunc ( Ηλικία 2 )
}
Στον προηγούμενο πηγαίο κώδικα, ορίσαμε μια διεπαφή με το όνομα 'EmpAge' που καθορίζει τους πιθανούς τύπους για την ηλικία ενός υπαλλήλου. Η διεπαφή περιλαμβάνει τους τύπους int64, int32, float32 και float64. Αυτή η διεπαφή επιτρέπει στη 'γενική' συνάρτηση να αποδεχτεί οποιονδήποτε από αυτούς τους τύπους ως όρισμα. Μετά από αυτό, χρησιμοποιούμε μια γενική συνάρτηση που ονομάζεται newGenericFunc που λαμβάνει την παράμετρο emp_Age ενός γενικού τύπου ηλικίας που μπορεί να είναι οποιοσδήποτε τύπος που ικανοποιεί τη διεπαφή EmpAge. Μέσα στη συνάρτηση, μετατρέπει το emp_Age σε int και το αυξάνει κατά 1 όπως φαίνεται.
Στη συνέχεια, δηλώνουμε τις δύο μεταβλητές, Age1 και Age2, και εκχωρούμε τις τιμές 24 και 25,5, αντίστοιχα, στην κύρια συνάρτηση. Στη συνέχεια, το Age1 και το Age2 μεταβιβάζονται ως παράμετροι στη συνάρτηση newGenericFunc, η οποία εκτελείται δύο φορές. Με αυτό, οι ηλικίες αυξάνονται κατά 1 και δημιουργούν τις ενημερωμένες τιμές.
Η έξοδος που προκύπτει στα παρακάτω είναι οι ηλικίες από τη γενική συνάρτηση που χρησιμοποιεί τη διεπαφή:
Παράδειγμα 3: Χρήση της Γενικής Δομής Δεδομένων Golang
Επιπλέον, το Go generic μας δίνει επίσης τη δυνατότητα να δημιουργήσουμε τις γενικές δομές δεδομένων όπως στοίβες, ουρές και συνδεδεμένες λίστες. Εξετάστε την υλοποίηση της γενικής στοίβας στα ακόλουθα:
εισαγωγή 'fmt'τύπος Σωρός [ Τ οποιοδήποτε ] [] Τ
func ( αγ * Σωρός [ Τ ]) Σπρώξτε ( στοιχείο Τ ) {
αγ = προσαρτώ ( * αγ , είδος )
}
func ( αγ * Σωρός [ Τ ]) Κρότος () Τ {
αν μόνο ( * αγ ) == 0 {
πανικός ( 'Τίποτα στη στοίβα' )
}
δείκτης := μόνο ( * αγ ) - 1
είδος := ( * αγ )[ δείκτης ]
* αγ = ( * αγ )[: δείκτης ]
ΕΠΙΣΤΡΟΦΗ είδος
}
func κύριος () {
σωρός := νέος ( Σωρός [ ενθ ])
σωρός . Σπρώξτε ( 1 )
σωρός . Σπρώξτε ( 2 )
σωρός . Σπρώξτε ( 3 )
fmt . Println ( σωρός . Κρότος ())
fmt . Println ( σωρός . Κρότος ())
fmt . Println ( σωρός . Κρότος ())
}
Στον προηγούμενο κώδικα, ορίζεται ένας γενικός τύπος με τίτλο «Στοίβα» που αντιπροσωπεύει τη στοίβα. Το σύμβολο κράτησης θέσης 'T' επιτρέπει στη στοίβα να συγκρατεί τα στοιχεία οποιουδήποτε τύπου. Ο τύπος «Στοίβα» υλοποιείται ως ένα κομμάτι στοιχείων του τύπου «Τ». Εδώ, αναπτύσσονται δύο λειτουργίες για τον τύπο 'Stack': 'Push' και 'Pop'. Η συνάρτηση Push() είναι υπεύθυνη για την προσθήκη των στοιχείων στη στοίβα. Παίρνει ένα στοιχείο ορίσματος τύπου 'T' και το προσαρτά στο υποκείμενο τμήμα χρησιμοποιώντας τη συνάρτηση append().
Ενώ η συνάρτηση Pop() παίρνει το αρχικό στοιχείο από τη στοίβα και το επιστρέφει, πρώτα καθορίζει εάν η στοίβα είναι άδεια αξιολογώντας το μέγεθος του υποκείμενου κομματιού. Αποστέλλεται ειδοποίηση σφάλματος εάν η στοίβα φαίνεται άδεια, κάτι που προκαλεί πανικό. Διαφορετικά, ανακτά το τελευταίο στοιχείο από τη φέτα, το αφαιρεί από τη στοίβα κόβοντας τη φέτα μέχρι το στοιχείο από το δεύτερο προς το τελευταίο και επιστρέφει το αφαιρεμένο στοιχείο.
Στη συνέχεια, δημιουργείται η νέα στοίβα ακεραίων με χρήση της σύνταξης Stack[int] εντός της κύριας συνάρτησης αυτού του κώδικα. Μετά από αυτό, η μέθοδος 'Push' καλείται τρεις φορές για να προσθέσει τους ακέραιους αριθμούς 1, 2 και 3 στη στοίβα. Ωστόσο, η μέθοδος 'Pop' καλείται τρεις φορές στη συνέχεια για να ανακτήσει και να εκτυπώσει τα στοιχεία από τη στοίβα.
Η ακόλουθη έξοδος υποδεικνύει ότι τα στοιχεία αφαιρούνται από τη στοίβα με αντίστροφη σειρά:
Παράδειγμα 4: Χρήση των γενικών περιορισμών Golang
Το Go προσφέρει επίσης προσαρμοσμένους περιορισμούς που επιτρέπουν μεγάλη ευελιξία και καθορίζουν συγκεκριμένες απαιτήσεις για γενικές κατασκευές με βάση τις ανάγκες εφαρμογής τους. Ο κώδικας των προσαρμοσμένων γενικών περιορισμών παρέχεται στα ακόλουθα για επίδειξη:
πακέτο κύριοςεισαγωγή 'fmt'
τύπος Αριθμητικά διεπαφή {
int64 | float64
}
func κύριος () {
FloatValue := [] float64 { 2 . 0 , 4 . 0 , 6 . 0 , 8 . 0 , 10 . 0 }
IntegerValue := [] int64 { 2 , 4 , 6 , 8 , 10 }
άθροισμα 1 := genericSum ( FloatValue )
άθροισμα 2 := genericSum ( IntegerValue
fmt . Println ( 'Άθροισμα float64 :' , άθροισμα 1 )
fmt . Println ( 'Άθροισμα int64 :' , άθροισμα 2 )
}
func genericSum [ n Αριθμητικά ]( αριθμοί [] n ) n {
ήταν είμαι ν
Για _ , σε ένα := εύρος αριθμοί {
άθροισμα += σε ένα
}
ΕΠΙΣΤΡΟΦΗ άθροισμα
}
Στον προηγούμενο πηγαίο κώδικα, ορίζουμε τη διεπαφή Numerics με τη μέθοδο 'Sum'. Στη συνέχεια, δημιουργούμε δύο προσαρμοσμένους τύπους, τους 'FloatValue' και 'IntegerValue', οι οποίοι υλοποιούν τη διεπαφή Numerics παρέχοντας τις αντίστοιχες μεθόδους 'Sum'. Η συνάρτηση genericSum είναι πλέον σε θέση να δέχεται τις φέτες οποιουδήποτε τύπου που ικανοποιεί τη διεπαφή Numerics. Μέσα στη συνάρτηση, επαναλαμβάνουμε τα στοιχεία και καλούμε τη μέθοδο 'Sum' για να υπολογίσουμε το άθροισμα. Τέλος, στην κύρια συνάρτηση, δημιουργούμε τα slices των FloatValue και IntegerValue και τα περνάμε στη συνάρτηση genericSum() που υπολογίζει σωστά το άθροισμα των στοιχείων σε κάθε slice.
Η αναμενόμενη έξοδος είναι πλέον ορατή στην ακόλουθη οθόνη:
συμπέρασμα
Εξερευνήσαμε μερικά πρακτικά παραδείγματα Go generic που περιλαμβάνουν τη δημιουργία μιας γενικής δομής δεδομένων και γενικής συνάρτησης, τον ορισμό μιας γενικής διεπαφής και τη χρήση του περιορισμού προσαρμοσμένου τύπου. Αυτά τα παραδείγματα καταδεικνύουν τη δύναμη και την ευελιξία που προσφέρουν τα γενικά στη γλώσσα προγραμματισμού Go. Σημειώστε ότι η δημιουργία κώδικα γενικής χρήσης κατά τη μεταγλώττιση διασφαλίζει το αποτελεσματικό δυαδικό μέγεθος και τους χρόνους μεταγλώττισης.