Higit sa lahat, pinapanatili ng mga generic ang malakas na kaligtasan ng uri ng Go na nagbibigay-daan sa static na pagsusuri ng uri sa oras ng pag-compile at tinitiyak ang kawastuhan ng uri. Nagbibigay ang mga ito ng standardized na paghawak ng error sa loob ng generic na code na nagpapabuti sa kalinawan at pagpapanatili. Bukod pa rito, nagbibigay sila ng standardized na paghawak ng error sa loob ng generic na code na nagpapabuti sa kalinawan at pagpapanatili. Sa post na ito, susuriin namin ang ilang mga real-world na Go generics application at mga halimbawa.
Halimbawa 1: Paggamit ng Golang Generic Function
Ang isa sa mga pangunahing kaso ng paggamit para sa mga generic ay ang paglikha ng mga function na maaaring gumana sa mga natatanging uri. Dito, pupunta tayo sa isa sa mga halimbawa kung saan ginagamit ang generic circumference function.
pakete pangunahing
angkat 'fmt'
func circumference [ r int | lumutang32 ]( radius r ) {
c := 3 * 2 * radius
fmt . Println ( 'Ang generic na circumference ay: ' , c )
}
func pangunahing () {
ay r1 int = 7
ay r2 lumutang32 = 7 . 5
circumference ( r1 )
circumference ( r2 )
}
Sa simula ng nakaraang code, ini-import ng linya ang package na 'fmt' na nagbibigay ng mga function para sa na-format na I/O, kabilang ang pag-print ng output sa console. Pagkatapos, tinutukoy namin ang isang generic na function na pinangalanang 'circumference' na kumukuha ng isang parameter radius ng isang generic na uri na 'r' na maaaring alinman sa isang 'int' o isang 'float32'. Sa loob ng function, kinakalkula nito ang circumference sa pamamagitan ng pagpaparami ng radius sa pare-parehong halaga ng '3' at pagkatapos ay i-multiply ito sa '2'. Sa wakas, ini-print nito ang kinakalkula na circumference gamit ang 'fmt.Println'.
Susunod, mayroon tayong pangunahing function kung saan ang dalawang variable, r1 at r2, ay idineklara at itinalaga na may mga halaga ng 7 at 7.5, ayon sa pagkakabanggit. Pagkatapos nito, ang function na 'circumference' ay ini-invoke ng dalawang beses, na nagpapasa ng r1 at r2 bilang mga argumento.
Ipinapakita ng output ang pagkalkula sa pamamagitan ng pag-print ng mga circumference ng mga bilog sa sumusunod:
Halimbawa 2: Paggamit ng Golang Generic Interface
Bukod dito, tinutulungan kami ng mga generic ng Golang sa kanilang mga interface. Ang mga interface sa Go ay isang mahalagang tool upang mapadali ang muling paggamit ng code at polymorphism. Sa pamamagitan ng pagpapagana sa mga ito na gumana sa maraming uri, pinapataas ng mga generic ang kapangyarihan ng mga interface. Ang sumusunod ay ang source code ng Golang generics interface:
pakete pangunahing
angkat 'fmt'
uri EmpAge interface {
int64 | int32 | lumutang32 | lumutang64
}
func bagongGenericFunc [ edad Edad ]( emp_Edad ng edad ) {
val := int ( emp_Edad ) + 1
fmt . Println ( val )
}
func pangunahing () {
fmt . Println ( 'Edad ng mga Empleyado' )
ay Edad1 int64 = 24
ay Edad2 lumutang64 = 25 . 5
bagongGenericFunc ( Edad1 )
bagongGenericFunc ( Edad2 )
}
Sa nakaraang source code, tinukoy namin ang isang interface na pinangalanang 'EmpAge' na tumutukoy sa mga posibleng uri para sa edad ng isang empleyado. Kasama sa interface ang mga uri ng int64, int32, float32, at float64. Ang interface na ito ay nagbibigay-daan sa 'generic' na function na tanggapin ang alinman sa mga uri na ito bilang isang argumento. Pagkatapos noon, gumamit kami ng generic na function na pinangalanang newGenericFunc na kumukuha ng emp_Age parameter ng isang generic na uri ng edad na maaaring anumang uri na nakakatugon sa EmpAge interface. Sa loob ng function, kino-convert nito ang emp_Age sa isang int at dinadagdagan ito ng 1 gaya ng ipinapakita.
Susunod, ipinapahayag namin ang dalawang variable, Age1 at Age2, at itinalaga ang mga halaga ng 24 at 25.5, ayon sa pagkakabanggit, sa pangunahing function. Pagkatapos noon, ang Age1 at Age2 ay ipinapasa bilang mga parameter sa newGenericFunc function na sumasailalim sa pagpapatupad ng dalawang beses. Sa pamamagitan nito, ang mga edad ay tinataasan ng 1 at bumubuo ng mga na-update na halaga.
Ang output na yielded sa mga sumusunod ay ang mga edad mula sa generic na function na gumagamit ng interface:
Halimbawa 3: Paggamit ng Golang Generic Data Structure
Higit pa rito, binibigyan din tayo ng Go generics ng kakayahang bumuo ng mga generic na istruktura ng data tulad ng mga stack, queues, at mga naka-link na listahan. Isaalang-alang ang pagpapatupad ng generic stack sa mga sumusunod:
angkat 'fmt'uri salansan [ T any ] [] T
func ( st * salansan [ T ]) Itulak ( aytem T ) {
st = dugtungan ( * st , aytem )
}
func ( st * salansan [ T ]) Pop () T {
kung lamang ( * st ) == 0 {
panic ( 'Wala sa Stack' )
}
index := lamang ( * st ) - 1
aytem := ( * st )[ index ]
* st = ( * st )[: index ]
bumalik aytem
}
func pangunahing () {
salansan := bago ( salansan [ int ])
salansan . Itulak ( 1 )
salansan . Itulak ( 2 )
salansan . Itulak ( 3 )
fmt . Println ( salansan . Pop ())
fmt . Println ( salansan . Pop ())
fmt . Println ( salansan . Pop ())
}
Sa nakaraang code, ang isang generic na uri na pinamagatang 'Stack' ay tinukoy na kumakatawan sa stack. Ang placeholder ng 'T' ay nagpapahintulot sa stack na hawakan ang mga elemento ng anumang uri. Ang uri ng 'Stack' ay ipinatupad bilang isang slice ng mga elemento ng uri ng 'T'. Dito, dalawang function ang naka-deploy para sa uri ng 'Stack': 'Push' at 'Pop.' Ang Push() function ay responsable para sa pagdaragdag ng mga elemento sa stack. Ito ay nangangailangan ng isang argument item ng uri ng 'T' at idinagdag ito sa pinagbabatayan ng slice gamit ang append() function.
Habang kinukuha ng Pop() function ang paunang bahagi mula sa stack at ibinabalik ito, tinutukoy muna nito kung walang laman ang stack sa pamamagitan ng pagsusuri sa laki ng pinagbabatayan na slice. Ang isang abiso ng error ay ipinapadala kung ang stack ay tila walang laman na nagdudulot ng pagkasindak. Kung hindi, kinukuha nito ang huling elemento mula sa slice, inaalis ito mula sa stack sa pamamagitan ng paghiwa sa slice hanggang sa pangalawang-sa-huling elemento, at ibinabalik ang inalis na item.
Susunod, ang bagong stack ng mga integer ay nilikha gamit ang Stack[int] syntax sa loob ng pangunahing function ng code na ito. Pagkatapos nito, ang pamamaraang 'Push' ay tinatawag na tatlong beses upang idagdag ang mga integer 1, 2, at 3 sa stack. Gayunpaman, ang pamamaraang 'Pop' ay tinatawag na tatlong beses pagkatapos upang kunin at i-print ang mga elemento mula sa stack.
Ang sumusunod na output ay nagpapahiwatig na ang mga elemento ay tinanggal mula sa stack sa reverse order:
Halimbawa 4: Paggamit ng Golang Generic Constraints
Nag-aalok din ang Go ng mga custom na hadlang na nagbibigay-daan sa isang mahusay na kakayahang umangkop at tumutukoy sa mga partikular na kinakailangan para sa mga generic na konstruksyon batay sa kanilang mga pangangailangan sa aplikasyon. Ang code ng custom na generic na mga hadlang ay ibinigay sa sumusunod para sa pagpapakita:
pakete pangunahingangkat 'fmt'
uri Mga numero interface {
int64 | lumutang64
}
func pangunahing () {
FloatValue := [] lumutang64 { 2 . 0 , 4 . 0 , 6 . 0 , 8 . 0 , 10 . 0 }
IntegerValue := [] int64 { 2 , 4 , 6 , 8 , 10 }
kabuuan1 := genericSum ( FloatValue )
kabuuan2 := genericSum ( IntegerValue
fmt . Println ( 'Kabuuan ng float64 :' , kabuuan1 )
fmt . Println ( 'Kabuuan ng int64 :' , kabuuan2 )
}
func genericSum [ n Mga numero ]( numero [] n ) n {
ay Ako si n
para sa _ , sa isa := saklaw numero {
sum += sa isa
}
bumalik sum
}
Sa naunang source code, tinukoy namin ang interface ng Numerics gamit ang pamamaraang 'Sum'. Pagkatapos, gumawa kami ng dalawang custom na uri, 'FloatValue' at 'IntegerValue', na nagpapatupad ng interface ng Numerics sa pamamagitan ng pagbibigay ng kani-kanilang 'Sum' na pamamaraan. Ang genericSum function ay nagagawa na ngayong tanggapin ang mga hiwa ng anumang uri na nakakatugon sa interface ng Numerics. Sa loob ng function, inuulit namin ang mga elemento at tinatawag ang 'Sum' na paraan upang kalkulahin ang kabuuan. Sa wakas, sa pangunahing function, ginagawa namin ang mga hiwa ng FloatValue at IntegerValue at ipinapasa ang mga ito sa genericSum() function na wastong kinakalkula ang kabuuan ng mga elemento sa bawat slice.
Ang inaasahang output ay makikita na ngayon sa sumusunod na screen:
Konklusyon
Nag-explore kami ng ilang praktikal na halimbawa ng Go generics na kinabibilangan ng paggawa ng generic na istraktura ng data at generic na function, pagtukoy ng generic na interface, at paggamit ng custom na uri ng hadlang. Ang mga halimbawang ito ay nagpapakita ng kapangyarihan at flexibility na dinadala ng mga generic sa Go programming language. Tandaan na tinitiyak ng generics code generation sa panahon ng compilation ang mahusay na laki ng binary at mga oras ng compilation.