Eksempler på generiske Golang

Eksempler Pa Generiske Golang



Golangs generiske funksjon gjør det mulig å lage en gjenbrukbar kode som er typesikker og kompatibel med et bredt spekter av typer. Heldigvis åpner tillegget av generiske medisiner til Go nye veier for gjenbruk av kode og fleksibilitet. Den siste versjonen av Golang bringer med seg den etterlengtede støtten for generiske legemidler.

Enda viktigere er at generikk opprettholder Gos sterke typesikkerhet som muliggjør statisk typekontroll ved kompilering og sikrer at typen er korrekt. De gir en standardisert feilhåndtering innenfor generisk kode som forbedrer klarhet og vedlikehold. I tillegg gir de en standardisert feilhåndtering innenfor den generiske koden som forbedrer klarheten og vedlikeholdsevnen. I dette innlegget vil vi undersøke de flere virkelige Go generiske applikasjonene og eksemplene.

Eksempel 1: Bruk av den generelle Golang-funksjonen

En av de viktigste brukssakene for generiske medisiner er å lage funksjoner som kan operere på forskjellige typer. Her går vi med et av eksemplene der den generiske omkretsfunksjonen brukes.







pakke hoved-
import 'fmt'
func omkrets [ r int | flyte32 ]( radius r ) {
c := 3 * 2 * radius
fmt . Println ( 'Den generiske omkretsen er:' , c )
}
func hoved- () {
var r1 int = 7
var r2 flyte32 = 7 . 5
omkrets ( r1 )
omkrets ( r2 )
}

I begynnelsen av forrige kode importerer linjen 'fmt'-pakken som gir funksjoner for formatert I/O, inkludert utskrift av utdata til konsollen. Deretter definerer vi en generisk funksjon kalt 'omkrets' som tar en parameterradius av en generisk type 'r' som enten kan være en 'int' eller en 'float32'. Inne i funksjonen beregner den omkretsen ved å multiplisere radiusen med den konstante verdien av '3' og deretter multiplisere den med '2'. Til slutt skriver den ut den beregnede omkretsen ved å bruke 'fmt.Println'.



Deretter har vi hovedfunksjonen der to variabler, r1 og r2, er deklarert og tilordnet verdiene på henholdsvis 7 og 7,5. Etter det blir 'omkrets'-funksjonen påkalt to ganger, og sender r1 og r2 som argumenter.



Utdataene viser beregningen ved å skrive ut omkretsene til sirklene i følgende:





Eksempel 2:  Bruke det generelle Golang-grensesnittet

Dessuten hjelper Golang generikk oss med deres grensesnitt. Grensesnitt i Go er et viktig verktøy for å lette gjenbruk av kode og polymorfisme. Ved å gjøre dem i stand til å fungere med mange typer, øker generiske grensesnitt kraften. Følgende er kildekoden til Golang generiske grensesnitt:



pakke hoved-
import 'fmt'
type EmpAge grensesnitt {
int64 | int32 | flyte32 | flyte64
}
func newGenericFunc [ alder Alder ]( emp_Alder alder ) {
val := int ( emp_Alder ) + 1
fmt . Println ( val )
}
func hoved- () {
fmt . Println ( 'Alder på ansatte' )
var Alder 1 int64 = 24
var Alder 2 flyte64 = 25 . 5
newGenericFunc ( Alder 1 )
newGenericFunc ( Alder 2 )
}

I den forrige kildekoden definerte vi et grensesnitt kalt 'EmpAge' som spesifiserer mulige typer for en ansatts alder. Grensesnittet inkluderer typene int64, int32, float32 og float64. Dette grensesnittet lar den 'generiske' funksjonen akseptere alle disse typene som et argument. Etter det bruker vi en generisk funksjon kalt newGenericFunc som tar parameteren emp_Age til en generisk alderstype som kan være hvilken som helst type som tilfredsstiller EmpAge-grensesnittet. Inne i funksjonen konverterer den emp_Age til en int og øker den med 1 som vist.

Deretter erklærer vi de to variablene, Alder1 og Alder2, og tildeler verdiene på henholdsvis 24 og 25,5 i hovedfunksjonen. Deretter sendes Age1 og Age2 som parametere til newGenericFunc-funksjonen som gjennomgår en utførelse to ganger. Med dette heves alderen med 1 og genererer de oppdaterte verdiene.

Utdataene som er gitt i det følgende er alderen fra den generiske funksjonen som bruker grensesnittet:

Eksempel 3: Bruk av Golangs generiske datastruktur

Videre gir Go generics oss også muligheten til å bygge generiske datastrukturer som stabler, køer og koblede lister. Vurder implementeringen av den generiske stabelen i følgende:

import 'fmt'
type Stable [ T noen ] [] T
func ( st * Stable [ T ]) Trykk ( element T ) {
st = legge til ( * st , punkt )
}
func ( st * Stable [ T ]) Pop () T {
hvis bare ( * st ) == 0 {
panikk ( 'Ingenting i stabelen' )
}
indeks := bare ( * st ) - 1
punkt := ( * st )[ indeks ]
* st = ( * st )[: indeks ]
komme tilbake punkt
}
func hoved- () {
stable := ny ( Stable [ int ])
stable . Trykk ( 1 )
stable . Trykk ( 2 )
stable . Trykk ( 3 )
fmt . Println ( stable . Pop ())
fmt . Println ( stable . Pop ())
fmt . Println ( stable . Pop ())
}

I forrige kode er en generisk type med tittelen 'Stack' definert som representerer stabelen. 'T'-plassholderen lar stabelen inneholde elementer av enhver type. 'Stack'-typen er implementert som en del av elementer av typen 'T'. Her er to funksjoner utplassert for 'Stack'-typen: 'Push' og 'Pop.' Push()-funksjonen er ansvarlig for å legge til elementene i stabelen. Den tar et argumentelement av typen 'T' og legger det til den underliggende skiven ved å bruke append()-funksjonen.

Mens Pop()-funksjonen tar den første komponenten fra stabelen og returnerer den, bestemmer den først om stabelen er tom ved å evaluere størrelsen på den underliggende skiven. En feilmelding sendes hvis stabelen ser ut til å være tom, noe som forårsaker panikk. Ellers henter den det siste elementet fra skiven, fjerner det fra stabelen ved å skjære skiven opp til det nest siste elementet, og returnerer det fjernede elementet.

Deretter opprettes den nye stabelen med heltall ved å bruke Stack[int]-syntaksen innenfor hovedfunksjonen til denne koden. Etter det kalles 'Push'-metoden tre ganger for å legge til heltallene 1, 2 og 3 til stabelen. Imidlertid kalles 'Pop'-metoden tre ganger etterpå for å hente og skrive ut elementene fra stabelen.

Følgende utgang indikerer at elementene er fjernet fra stabelen i omvendt rekkefølge:

Eksempel 4: Bruk av Golang Generic Constraints

Go tilbyr også tilpassede begrensninger som muliggjør stor fleksibilitet og definerer spesifikke krav for generiske konstruksjoner basert på deres applikasjonsbehov. Koden til de tilpassede generiske begrensningene er gitt i følgende for demonstrasjon:

pakke hoved-
import 'fmt'
type Numerikk grensesnitt {
int64 | flyte64
}
func hoved- () {
FloatValue := [] flyte64 { 2 . 0 , 4 . 0 , 6 . 0 , 8 . 0 , 10 . 0 }
Heltallsverdi := [] int64 { 2 , 4 , 6 , 8 , 10 }
sum1 := generisk Sum ( FloatValue )
sum2 := generisk Sum ( Heltallsverdi
fmt . Println ( 'Summen av float64 :' , sum1 )
fmt . Println ( 'Summen av int64 :' , sum2 )

}
func generisk Sum [ n Numerikk ]( tall [] n ) n {
var Jeg er n
til _ , på en := område tall {
sum += på en
}
komme tilbake sum
}

I den tidligere kildekoden definerer vi Numerics-grensesnittet med 'Sum'-metoden. Deretter lager vi to tilpassede typer, 'FloatValue' og 'IntegerValue', som implementerer Numerics-grensesnittet ved å gi deres respektive 'Sum'-metoder. GenericSum-funksjonen er nå i stand til å akseptere skivene av enhver type som tilfredsstiller Numerics-grensesnittet. Inne i funksjonen itererer vi over elementene og kaller «Sum»-metoden for å beregne summen. Til slutt, i hovedfunksjonen, lager vi skivene av FloatValue og IntegerValue og sender dem til genericSum()-funksjonen som korrekt beregner summen av elementene i hver skive.

Den forventede utgangen er nå synlig på følgende skjerm:

Konklusjon

Vi utforsket noen praktiske eksempler på Go-generikk som inkluderer opprettelse av en generisk datastruktur og generisk funksjon, definering av et generisk grensesnitt og bruk av den tilpassede typebegrensningen. Disse eksemplene viser kraften og fleksibiliteten som generiske medisiner tilfører programmeringsspråket Go. Merk at generering av generisk kode under kompilering sikrer effektiv binær størrelse og kompileringstider.