Še pomembneje je, da generiki ohranjajo močno varnost tipov Go, ki omogoča statično preverjanje tipov v času prevajanja in zagotavlja pravilnost tipov. Zagotavljajo standardizirano obravnavanje napak znotraj generične kode, ki izboljša jasnost in vzdržljivost. Poleg tega zagotavljajo standardizirano obravnavanje napak znotraj generične kode, kar izboljša jasnost in vzdržljivost. V tej objavi bomo preučili več generičnih aplikacij in primerov Go v resničnem svetu.
Primer 1: Uporaba generične funkcije Golang
Eden od primarnih primerov uporabe generikov je ustvarjanje funkcij, ki lahko delujejo na različnih vrstah. Tukaj gremo z enim od primerov, kjer je uporabljena generična funkcija obsega.
paket glavni
uvoz 'fmt'
funk obseg [ r int | float32 ]( polmer r ) {
c := 3 * 2 * polmer
fmt . Println ( 'Generični obseg je: ' , c )
}
funk glavni () {
je bil r1 int = 7
je bil r2 float32 = 7 . 5
obseg ( r1 )
obseg ( r2 )
}
Na začetku prejšnje kode vrstica uvozi paket »fmt«, ki nudi funkcije za formatiran V/I, vključno s tiskanjem izhoda na konzolo. Nato definiramo generično funkcijo z imenom »circumference«, ki prevzame polmer parametra generičnega tipa »r«, ki je lahko »int« ali »float32«. Znotraj funkcije izračuna obseg tako, da pomnoži polmer s konstantno vrednostjo »3« in ga nato pomnoži z »2«. Nazadnje natisne izračunani obseg s pomočjo »fmt.Println«.
Nato imamo glavno funkcijo, kjer sta dve spremenljivki, r1 in r2, deklarirani in dodeljeni z vrednostmi 7 oziroma 7,5. Po tem se dvakrat prikliče funkcija »circumference«, ki posreduje r1 in r2 kot argumenta.
Izhod prikaže izračun z izpisom obsegov krogov v naslednjem:
Primer 2: Uporaba splošnega vmesnika Golang
Poleg tega nam generiki Golang pomagajo s svojimi vmesniki. Vmesniki v Go so bistveno orodje za olajšanje ponovne uporabe kode in polimorfizma. Ker jim omogočajo delovanje s številnimi vrstami, generiki povečajo moč vmesnikov. Sledi izvorna koda generičnega vmesnika Golang:
paket glavni
uvoz 'fmt'
vrsta EmpAge vmesnik {
int64 | int32 | float32 | float64
}
funk newGenericFunc [ starost Starost ]( emp_Age starost ) {
val := int ( emp_Age ) + 1
fmt . Println ( val )
}
funk glavni () {
fmt . Println ( 'Starost zaposlenih' )
je bil Starost1 int64 = 24
je bil Starost2 float64 = 25 . 5
newGenericFunc ( Starost1 )
newGenericFunc ( Starost2 )
}
V prejšnji izvorni kodi smo definirali vmesnik z imenom »EmpAge«, ki določa možne vrste za starost zaposlenega. Vmesnik vključuje vrste int64, int32, float32 in float64. Ta vmesnik omogoča 'generični' funkciji, da sprejme katero koli od teh vrst kot argument. Po tem uporabimo generično funkcijo z imenom newGenericFunc, ki vzame parameter emp_Age generične vrste starosti, ki je lahko katera koli vrsta, ki ustreza vmesniku EmpAge. Znotraj funkcije pretvori emp_Age v int in ga poveča za 1, kot je prikazano.
Nato deklariramo dve spremenljivki, Age1 in Age2, in v glavni funkciji dodelimo vrednosti 24 oziroma 25,5. Nato se Age1 in Age2 kot parametra posredujeta funkciji newGenericFunc, ki se dvakrat izvede. S tem se starosti zvišajo za 1 in ustvarijo posodobljene vrednosti.
Izhod, ki je pridobljen v naslednjem, so starosti generične funkcije, ki uporablja vmesnik:
Primer 3: Uporaba generične podatkovne strukture Golang
Poleg tega nam generika Go omogoča tudi izgradnjo generičnih podatkovnih struktur, kot so skladi, čakalne vrste in povezani seznami. Razmislite o implementaciji generičnega sklada v naslednjem:
uvoz 'fmt'vrsta Stack [ T kateri koli ] [] T
funk ( st * Stack [ T ]) Potisni ( postavka T ) {
st = priložiti ( * st , postavka )
}
funk ( st * Stack [ T ]) Pop () T {
če samo ( * st ) == 0 {
panika ( 'Nič v skladu' )
}
kazalo := samo ( * st ) - 1
postavka := ( * st )[ kazalo ]
* st = ( * st )[: kazalo ]
vrnitev postavka
}
funk glavni () {
kup := novo ( Stack [ int ])
kup . Potisni ( 1 )
kup . Potisni ( 2 )
kup . Potisni ( 3 )
fmt . Println ( kup . Pop ())
fmt . Println ( kup . Pop ())
fmt . Println ( kup . Pop ())
}
V prejšnji kodi je definiran generični tip z naslovom “Sklad”, ki predstavlja sklad. Oznaka mesta »T« dovoljuje, da sklad vsebuje elemente katere koli vrste. Tip 'Stack' je implementiran kot rezina elementov tipa 'T'. Tukaj sta uporabljeni dve funkciji za vrsto »Stack«: »Push« in »Pop«. Funkcija Push() je odgovorna za dodajanje elementov v sklad. Vzame element argumenta tipa 'T' in ga doda osnovni rezini s pomočjo funkcije append().
Medtem ko funkcija Pop() vzame začetno komponento iz sklada in jo vrne, najprej ugotovi, ali je sklad prazen, tako da oceni velikost osnovne rezine. Če je sklad videti prazen, se pošlje obvestilo o napaki, kar povzroči paniko. V nasprotnem primeru pridobi zadnji element iz rezine, ga odstrani iz sklada tako, da rezino razreže do predzadnjega elementa, in vrne odstranjeni element.
Nato se ustvari nov sklad celih števil s sintakso Stack[int] znotraj glavne funkcije te kode. Po tem se trikrat pokliče metoda »Push«, da se v sklad dodajo cela števila 1, 2 in 3. Vendar pa je metoda »Pop« poklicana trikrat zatem, da pridobi in natisne elemente iz sklada.
Naslednji izhod kaže, da so elementi odstranjeni iz sklada v obratnem vrstnem redu:
Primer 4: Uporaba generičnih omejitev Golang
Go ponuja tudi omejitve po meri, ki omogočajo veliko prilagodljivost in določajo posebne zahteve za generične konstrukcije na podlagi njihovih potreb aplikacij. Koda generičnih omejitev po meri je za predstavitev na voljo v nadaljevanju:
paket glavniuvoz 'fmt'
vrsta Številke vmesnik {
int64 | float64
}
funk glavni () {
FloatValue := [] float64 { 2 . 0 , 4 . 0 , 6 . 0 , 8 . 0 , 10 . 0 }
IntegerValue := [] int64 { 2 , 4 , 6 , 8 , 10 }
vsota1 := genericSum ( FloatValue )
vsota2 := genericSum ( IntegerValue
fmt . Println ( 'Vsota float64:' , vsota1 )
fmt . Println ( 'Vsota int64:' , vsota2 )
}
funk genericSum [ n Številke ]( številke [] n ) n {
je bil jaz sem n
za _ , na enem := obseg številke {
vsota += na enem
}
vrnitev vsota
}
V prejšnji izvorni kodi definiramo vmesnik Numerics z metodo »Sum«. Nato ustvarimo dva tipa po meri, »FloatValue« in »IntegerValue«, ki implementirata vmesnik Numerics z zagotavljanjem svojih metod »Sum«. Funkcija genericSum lahko zdaj sprejme rezine katere koli vrste, ki ustreza vmesniku Numerics. Znotraj funkcije ponavljamo elemente in kličemo metodo »Sum« za izračun vsote. Končno v glavni funkciji ustvarimo rezine FloatValue in IntegerValue ter ju posredujemo funkciji genericSum(), ki pravilno izračuna vsoto elementov v vsaki rezini.
Pričakovani rezultat je zdaj viden na naslednjem zaslonu:
Zaključek
Raziskali smo nekaj praktičnih primerov generike Go, ki vključujejo ustvarjanje generične podatkovne strukture in generične funkcije, definiranje generičnega vmesnika in uporabo omejitve tipa po meri. Ti primeri prikazujejo moč in prilagodljivost, ki jo generiki prinašajo v programski jezik Go. Upoštevajte, da generiranje generične kode med prevajanjem zagotavlja učinkovito binarno velikost in čas prevajanja.