„Golang Generics“ pavyzdžiai

Golang Generics Pavyzdziai



„Golang“ bendroji funkcija leidžia sukurti pakartotinai naudojamą kodą, kuris yra saugus ir suderinamas su daugybe tipų. Laimei, „Go“ papildymas generiniais vaistais atveria naujas kodo pakartotinio naudojimo ir lankstumo galimybes. Naujausia Golang versija suteikia labai lauktą generinių vaistų palaikymą.

Dar svarbiau, kad generiniai vaistai palaiko tvirtą Go tipo saugą, kuri leidžia atlikti statinį tipo tikrinimą kompiliavimo metu ir užtikrina tipo teisingumą. Jie suteikia standartizuotą klaidų tvarkymą bendrame kode, kuris pagerina aiškumą ir priežiūrą. Be to, jie suteikia standartizuotą klaidų tvarkymą bendrame kode, kuris pagerina aiškumą ir priežiūrą. Šiame įraše išnagrinėsime keletą realaus pasaulio Go generinių programų ir pavyzdžių.

1 pavyzdys: „Golang“ bendrosios funkcijos naudojimas

Vienas iš pagrindinių generinių vaistų naudojimo atvejų yra funkcijų, kurios gali veikti su skirtingais tipais, kūrimas. Pateikiame vieną iš pavyzdžių, kur naudojama bendroji apskritimo funkcija.







paketą pagrindinis
importuoti 'fmt'
func perimetras [ r tarpt | plūdė32 ]( spindulys r ) {
c := 3 * 2 * spindulys
fmt . Println ( 'Bendra apimtis yra: ' , c )
}
func pagrindinis () {
buvo r1 tarpt = 7
buvo r2 plūdė32 = 7 . 5
perimetras ( r1 )
perimetras ( r2 )
}

Ankstesnio kodo pradžioje eilutė importuoja „fmt“ paketą, kuris suteikia suformatuoto įvesties / išvesties funkcijas, įskaitant išvesties spausdinimą į konsolę. Tada apibrėžiame bendrąją funkciją, pavadintą „circumference“, kuri įgauna bendrojo tipo „r“ parametro spindulį, kuris gali būti „int“ arba „float32“. Funkcijoje jis apskaičiuoja perimetrą, padaugindamas spindulį iš pastovios vertės „3“, o tada padaugindamas iš „2“. Galiausiai jis atspausdina apskaičiuotą perimetrą naudodamas „fmt.Println“.



Toliau turime pagrindinę funkciją, kurioje deklaruojami du kintamieji, r1 ir r2, ir jiems priskiriamos atitinkamai 7 ir 7,5 reikšmės. Po to funkcija „apimtis“ iškviečiama du kartus, kaip argumentus perduodant r1 ir r2.



Išvestyje rodomas skaičiavimas, atspausdinus apskritimų apskritimus taip:





2 pavyzdys: Golang bendrosios sąsajos naudojimas

Be to, „Golang“ generiniai vaistai padeda mums su savo sąsajomis. „Go“ sąsajos yra gyvybiškai svarbus įrankis, palengvinantis pakartotinį kodo naudojimą ir polimorfizmą. Suteikdami jiems galimybę veikti su daugeliu tipų, bendrieji vaistai padidina sąsajų galią. Toliau pateikiamas „Golang“ bendrosios sąsajos šaltinio kodas:



paketą pagrindinis
importuoti 'fmt'
tipo EmpAge sąsaja {
int64 | int32 | plūdė32 | plūdė64
}
func newGenericFunc [ amžius Amžius ]( emp_Age amžius ) {
val := tarpt ( emp_Age ) + 1
fmt . Println ( val )
}
func pagrindinis () {
fmt . Println ( „Darbuotojų amžius“ )
buvo Amžius1 int64 = 24
buvo Amžius 2 plūdė64 = 25 . 5
newGenericFunc ( Amžius1 )
newGenericFunc ( Amžius 2 )
}

Ankstesniame šaltinio kode apibrėžėme sąsają pavadinimu „EmpAge“, kuri nurodo galimus darbuotojo amžiaus tipus. Sąsaja apima int64, int32, float32 ir float64 tipus. Ši sąsaja leidžia „bendrai“ funkcijai priimti bet kurį iš šių tipų kaip argumentą. Po to mes naudojame bendrąją funkciją, pavadintą newGenericFunc, kuri paima bendro amžiaus tipo parametrą emp_Age, kuris gali būti bet kokio tipo, atitinkantis EmpAge sąsają. Funkcijos viduje ji konvertuoja emp_Age į int ir padidina jį 1, kaip parodyta.

Toliau deklaruojame du kintamuosius, Age1 ir Age2, ir pagrindinėje funkcijoje priskiriame atitinkamai 24 ir 25,5 reikšmes. Po to „Age1“ ir „Age2“ perduodami kaip parametrai „newGenericFunc“ funkcijai, kuri vykdoma du kartus. Tai padarius, amžius padidinamas 1 ir generuojamos atnaujintos vertės.

Išvestis, kuri pateikiama toliau, yra bendrosios funkcijos, kuri naudoja sąsają, amžius:

3 pavyzdys: Golango bendrosios duomenų struktūros naudojimas

Be to, „Go generics“ taip pat suteikia mums galimybę kurti bendras duomenų struktūras, pvz., rietuves, eiles ir susietus sąrašus. Apsvarstykite, kaip įgyvendinti bendrąjį krūvą:

importuoti 'fmt'
tipo Stack [ T bet koks ] [] T
func ( Šv * Stack [ T ]) Stumti ( punktas T ) {
Šv = pridėti ( * Šv , daiktas )
}
func ( Šv * Stack [ T ]) Pop () T {
jeigu tik ( * Šv ) == 0 {
panika ( „Nieko kamino“ )
}
indeksas := tik ( * Šv ) - 1
daiktas := ( * Šv )[ indeksas ]
* Šv = ( * Šv )[: indeksas ]
grąžinti daiktas
}
func pagrindinis () {
krūva := naujas ( Stack [ tarpt ])
krūva . Stumti ( 1 )
krūva . Stumti ( 2 )
krūva . Stumti ( 3 )
fmt . Println ( krūva . Pop ())
fmt . Println ( krūva . Pop ())
fmt . Println ( krūva . Pop ())
}

Ankstesniame kode yra apibrėžtas bendras tipas, pavadintas „Stack“, kuris reiškia krūvą. „T“ vietos rezervavimo ženklas leidžia krūvoje laikyti bet kokio tipo elementus. „Stack“ tipas įgyvendinamas kaip „T“ tipo elementų dalis. Čia „Stack“ tipui naudojamos dvi funkcijos: „Push“ ir „Pop“. Funkcija Push() yra atsakinga už elementų įtraukimą į krūvą. Jis paima „T“ tipo argumento elementą ir prideda jį prie pagrindinio pjūvio, naudodamas funkciją append().

Nors funkcija Pop() paima pradinį komponentą iš krūvos ir jį grąžina, ji pirmiausia nustato, ar dėklas tuščias, įvertindama pagrindinės dalies dydį. Klaidos pranešimas siunčiamas, jei atrodo, kad krūva tuščia, o tai sukelia paniką. Kitu atveju jis nuskaito paskutinį elementą iš skilties, pašalina jį iš krūvos, supjaustydamas gabalą iki antrojo iki paskutinio elemento, ir grąžina pašalintą elementą.

Tada naujas sveikųjų skaičių krūvas sukuriamas naudojant Stack[int] sintaksę pagrindinėje šio kodo funkcijoje. Po to tris kartus iškviečiamas „Push“ metodas, kad į krūvą būtų įtraukti sveikieji skaičiai 1, 2 ir 3. Tačiau „Pop“ metodas iškviečiamas tris kartus vėliau, norint gauti ir spausdinti elementus iš krūvos.

Ši išvestis rodo, kad elementai pašalinami iš krūvos atvirkštine tvarka:

4 pavyzdys: Golango bendrųjų apribojimų naudojimas

„Go“ taip pat siūlo pasirinktinius apribojimus, kurie suteikia didelį lankstumą ir apibrėžia specifinius bendrųjų konstrukcijų reikalavimus, atsižvelgiant į jų taikymo poreikius. Pasirinktinių bendrųjų apribojimų kodas pateikiamas toliau, kad būtų parodyta:

paketą pagrindinis
importuoti 'fmt'
tipo Skaičiai sąsaja {
int64 | plūdė64
}
func pagrindinis () {
FloatValue := [] plūdė64 { 2 . 0 , 4 . 0 , 6 . 0 , 8 . 0 , 10 . 0 }
IntegerValue := [] int64 { 2 , 4 , 6 , 8 , 10 }
suma1 := bendrojiSuma ( FloatValue )
suma2 := bendrojiSuma ( IntegerValue
fmt . Println ( 'Sum of float64 :' , suma1 )
fmt . Println ( 'Sum of int64 :' , suma2 )

}
func bendrojiSuma [ n Skaičiai ]( numeriai [] n ) n {
buvo Aš esu n
dėl _ , ant vieno := diapazonas numeriai {
suma += ant vieno
}
grąžinti suma
}

Ankstesniame šaltinio kode numerių sąsają apibrėžiame metodu „Suma“. Tada sukuriame du pasirinktinius tipus „FloatValue“ ir „IntegerValue“, kurie įgyvendina „Numerics“ sąsają pateikdami atitinkamus „Sum“ metodus. Funkcija „genericSum“ dabar gali priimti bet kokio tipo skilteles, kurios atitinka „Numerics“ sąsają. Funkcijoje kartojame elementus ir iškviečiame „Sum“ metodą, norėdami apskaičiuoti sumą. Galiausiai pagrindinėje funkcijoje sukuriame FloatValue ir IntegerValue dalis ir perduodame jas funkcijai genericSum(), kuri teisingai apskaičiuoja kiekvienos skilties elementų sumą.

Numatyta išvestis dabar matoma šiame ekrane:

Išvada

Išnagrinėjome keletą praktinių „Go generics“ pavyzdžių, įskaitant bendrosios duomenų struktūros ir bendrosios funkcijos kūrimą, bendrosios sąsajos apibrėžimą ir tinkinto tipo apribojimo naudojimą. Šie pavyzdžiai parodo galią ir lankstumą, kurią generiniai vaistai suteikia Go programavimo kalbai. Atminkite, kad generinio kodo generavimas kompiliavimo metu užtikrina efektyvų dvejetainį dydį ir kompiliavimo laiką.