Veelgi olulisem on see, et geneerilised ravimid säilitavad Go tugeva tüübiohutuse, mis võimaldab staatilist tüübikontrolli kompileerimise ajal ja tagab tüübi õigsuse. Need pakuvad standardiseeritud veakäsitlust üldises koodis, mis parandab selgust ja hooldatavust. Lisaks pakuvad need üldises koodis standardiseeritud veakäsitlust, mis parandab selgust ja hooldatavust. Selles postituses uurime mitmeid reaalse maailma Go geneeriliste rakenduste ja näiteid.
Näide 1: Golangi üldfunktsiooni kasutamine
Üks geneeriliste ravimite peamisi kasutusjuhte on funktsioonide loomine, mis võivad töötada erinevatel tüüpidel. Siin on üks näidetest, kus kasutatakse üldist ümbermõõdu funktsiooni.
pakett peamine
importida 'fmt'
func ümbermõõt [ r int | ujuk32 ]( raadius r ) {
c := 3 * 2 * raadius
fmt . Println ( 'Üldine ümbermõõt on:' , c )
}
func peamine () {
oli r1 int = 7
oli r2 ujuk32 = 7 . 5
ümbermõõt ( r1 )
ümbermõõt ( r2 )
}
Eelmise koodi alguses impordib rida 'fmt' pakett, mis pakub funktsioone vormindatud I/O jaoks, sealhulgas väljundi printimiseks konsooli. Seejärel defineerime üldfunktsiooni nimega 'circumference', mis võtab üldist tüüpi 'r' parameetri raadiuse, mis võib olla kas 'int' või 'float32'. Funktsiooni sees arvutab see ümbermõõdu, korrutades raadiuse konstantse väärtusega '3' ja korrutades selle seejärel '2-ga'. Lõpuks prindib see välja arvutatud ümbermõõdu, kasutades 'fmt.Println'.
Järgmisena on meil põhifunktsioon, kus deklareeritakse kaks muutujat, r1 ja r2, ja omistatakse neile vastavalt väärtused 7 ja 7,5. Pärast seda käivitatakse funktsioon 'ümbermõõt' kaks korda, edastades argumentidena r1 ja r2.
Väljund kuvab arvutuse, trükkides ringide ümbermõõdud järgmiselt:
Näide 2: Golangi üldise liidese kasutamine
Lisaks aitavad Golangi geneerilised ravimid meid oma liidestega. Go liidesed on oluline tööriist koodi taaskasutamise ja polümorfismi hõlbustamiseks. Võimaldades neil töötada paljude tüüpidega, suurendavad geneerilised ravimid liideste võimsust. Järgmine on Golangi üldise liidese lähtekood:
pakett peamine
importida 'fmt'
tüüp EmpAge liides {
int64 | int32 | ujuk32 | ujuk64
}
func uusGenericFunc [ vanus Vanus ]( emp_Age vanus ) {
val := int ( emp_Vanus ) + 1
fmt . Println ( val )
}
func peamine () {
fmt . Println ( 'Töötajate vanus' )
oli Vanus1 int64 = 24
oli Vanus2 ujuk64 = 25 . 5
uusGenericFunc ( Vanus1 )
uusGenericFunc ( Vanus2 )
}
Eelmises lähtekoodis määratlesime liidese nimega 'EmpAge', mis määrab võimalikud tüübid vastavalt töötaja vanusele. Liides sisaldab tüüpe int64, int32, float32 ja float64. See liides võimaldab 'üldisel' funktsioonil aktsepteerida kõiki neid tüüpe argumendina. Pärast seda kasutame üldist funktsiooni nimega newGenericFunc, mis võtab üldise vanusetüübi parameetri emp_Age, mis võib olla mis tahes tüüpi, mis vastab EmpAge'i liidesele. Funktsiooni sees teisendab see emp_Age väärtuseks int ja suurendab seda 1 võrra, nagu näidatud.
Järgmisena deklareerime kaks muutujat Vanus1 ja Vanus2 ning määrame põhifunktsioonis vastavalt väärtused 24 ja 25,5. Seejärel edastatakse Age1 ja Age2 parameetritena funktsioonile newGenericFunc, mida täidetakse kaks korda. Sellega tõstetakse vanust 1 võrra ja genereeritakse värskendatud väärtused.
Järgnevalt saadav väljund on liidest kasutava üldise funktsiooni vanused:
Näide 3: Golangi üldise andmestruktuuri kasutamine
Lisaks annab Go generics meile ka võimaluse luua üldisi andmestruktuure, nagu virnad, järjekorrad ja lingitud loendid. Kaaluge üldise viru rakendamist järgmiselt.
importida 'fmt'tüüp Virna [ T tahes ] [] T
func ( St * Virna [ T ]) Push ( ese T ) {
St = lisama ( * St , üksus )
}
func ( St * Virna [ T ]) Pop () T {
kui ainult ( * St ) == 0 {
paanika ( 'Pole midagi virnas' )
}
indeks := ainult ( * St ) - 1
üksus := ( * St )[ indeks ]
* St = ( * St )[: indeks ]
tagasi üksus
}
func peamine () {
virna := uus ( Virna [ int ])
virna . Push ( 1 )
virna . Push ( 2 )
virna . Push ( 3 )
fmt . Println ( virna . Pop ())
fmt . Println ( virna . Pop ())
fmt . Println ( virna . Pop ())
}
Eelmises koodis on defineeritud üldine tüüp pealkirjaga 'Stack', mis tähistab virna. T-kohatäide võimaldab virnal hoida mis tahes tüüpi elemente. Tüüp 'Stack' on rakendatud 'T-tüüpi' elementide osana. Siin on 'Stack' tüübi jaoks juurutatud kaks funktsiooni: 'Push' ja 'Pop'. Funktsioon Push() vastutab elementide virnasse lisamise eest. See võtab T-tüüpi argumendiüksuse ja lisab selle aluseks olevale lõigule funktsiooni append() abil.
Kuigi funktsioon Pop() võtab virust algkomponendi ja tagastab selle, määrab see kõigepealt kindlaks, kas virn on tühi, hinnates aluseks oleva lõigu suurust. Kui virn näib olevat tühi, saadetakse veateade, mis põhjustab paanikat. Vastasel juhul hangib see lõigust viimase elemendi, eemaldab selle virnast, lõigates viilu kuni viimase elemendini, ja tagastab eemaldatud elemendi.
Järgmisena luuakse uus täisarvude virn, kasutades selle koodi põhifunktsiooni Stack[int] süntaksit. Pärast seda kutsutakse kolm korda meetodit Push, et lisada virna täisarvud 1, 2 ja 3. Kuid 'Pop' meetodit kutsutakse kolm korda järjest, et virnast elemendid alla laadida ja printida.
Järgmine väljund näitab, et elemendid eemaldatakse virnast vastupidises järjekorras:
Näide 4: Golangi üldiste piirangute kasutamine
Go pakub ka kohandatud piiranguid, mis võimaldavad suurt paindlikkust ja määratlevad spetsiifilised nõuded üldistele konstruktsioonidele nende rakendusvajaduste põhjal. Kohandatud üldiste piirangute kood on demonstreerimiseks esitatud järgmiselt.
pakett peamineimportida 'fmt'
tüüp Numbrid liides {
int64 | ujuk64
}
func peamine () {
FloatValue := [] ujuk64 { 2 . 0 , 4 . 0 , 6 . 0 , 8 . 0 , 10 . 0 }
IntegerValue := [] int64 { 2 , 4 , 6 , 8 , 10 }
summa1 := üldineSum ( FloatValue )
summa2 := üldineSum ( IntegerValue
fmt . Println ( 'Sum of float64 :' , summa1 )
fmt . Println ( 'Sum of int64 :' , summa2 )
}
func üldineSum [ n Numbrid ]( numbrid [] n ) n {
oli ma olen n
jaoks _ , ühel := ulatus numbrid {
summa += ühel
}
tagasi summa
}
Varasemas lähtekoodis defineerime numbriliidese 'Summa' meetodiga. Seejärel loome kaks kohandatud tüüpi „FloatValue” ja „IntegerValue”, mis rakendavad numbriliidest, pakkudes vastavaid „Summa” meetodeid. Funktsioon genericSum suudab nüüd vastu võtta mis tahes tüüpi osi, mis vastavad numbriliidesele. Funktsiooni sees kordame elemente ja kutsume summa arvutamiseks välja meetodi 'Summa'. Lõpuks loome põhifunktsioonis FloatValue ja IntegerValue lõigud ning edastame need funktsioonile genericSum(), mis arvutab õigesti iga lõigu elementide summa.
Eeldatav väljund on nüüd nähtav järgmisel ekraanil:
Järeldus
Uurisime mõningaid praktilisi näiteid Go geneerikutest, mis hõlmavad üldise andmestruktuuri ja üldise funktsiooni loomist, üldise liidese määratlemist ja kohandatud tüübipiirangu kasutamist. Need näited näitavad võimsust ja paindlikkust, mida geneerilised ravimid Go programmeerimiskeelde toovad. Pange tähele, et üldise koodi genereerimine kompileerimise ajal tagab tõhusa binaarsuuruse ja kompileerimisajad.