Vielä tärkeämpää on, että geneeriset tuotteet ylläpitävät Go:n vahvaa tyyppiturvaa, joka mahdollistaa staattisen tyyppitarkistuksen käännöshetkellä ja varmistaa tyypin oikeellisuuden. Ne tarjoavat standardoidun virheenkäsittelyn yleisessä koodissa, mikä parantaa selkeyttä ja ylläpidettävyyttä. Lisäksi ne tarjoavat standardoidun virheenkäsittelyn yleisessä koodissa, mikä parantaa selkeyttä ja ylläpidettävyyttä. Tässä viestissä tarkastelemme useita todellisia Go-geneerisovelluksia ja esimerkkejä.
Esimerkki 1: Golangin yleisfunktion käyttö
Yksi geneeristen tuotteiden ensisijaisista käyttötapauksista on funktioiden luominen, jotka voivat toimia eri tyypeillä. Tässä on yksi esimerkki, jossa käytetään yleistä ympärysmittafunktiota.
paketti pää
tuonti 'fmt'
func ympärysmitta [ r int | kellua32 ]( säde r ) {
c := 3 * 2 * säde
fmt . Println ( 'Yleinen ympärysmitta on:' , c )
}
func pää () {
oli r1 int = 7
oli r2 kellua32 = 7 . 5
ympärysmitta ( r1 )
ympärysmitta ( r2 )
}
Edellisen koodin alussa rivi tuo 'fmt'-paketin, joka tarjoaa toimintoja muotoillulle I/O:lle, mukaan lukien tulosteen tulostamisen konsoliin. Sitten määritämme yleisen funktion nimeltä 'ympärysmitta', joka ottaa parametrisäteen yleistä tyyppiä 'r', joka voi olla joko 'int' tai 'float32'. Toiminnon sisällä se laskee kehän kertomalla säteen vakioarvolla '3' ja kertomalla sen sitten '2':lla. Lopuksi se tulostaa lasketun ympärysmitan käyttämällä 'fmt.Println'.
Seuraavaksi meillä on pääfunktio, jossa kaksi muuttujaa, r1 ja r2, ilmoitetaan ja niille annetaan arvot 7 ja 7,5. Tämän jälkeen 'ympärysmitta'-funktiota vedetään kahdesti ohittaen r1 ja r2 argumentteina.
Tulos näyttää laskelman tulostamalla ympyröiden ympärysmitat seuraavasti:
Esimerkki 2: Golangin yleisen käyttöliittymän käyttäminen
Lisäksi Golangin geneeriset tuotteet auttavat meitä käyttöliittymiensä kanssa. Go-liittymät ovat tärkeä työkalu koodin uudelleenkäytön ja polymorfismin helpottamiseksi. Generics lisää rajapintojen tehoa mahdollistamalla niiden toiminnan useiden tyyppien kanssa. Seuraava on Golangin yleiskäyttöliittymän lähdekoodi:
paketti pää
tuonti 'fmt'
tyyppi EmpAge käyttöliittymä {
int64 | int32 | kellua32 | kellua64
}
func uusiGenericFunc [ ikä Ikä ]( emp_Ikä ikä ) {
val := int ( emp_Ikä ) + 1
fmt . Println ( val )
}
func pää () {
fmt . Println ( 'Työntekijöiden ikä' )
oli Ikä1 int64 = 24
oli Ikä2 kellua64 = 25 . 5
uusiGenericFunc ( Ikä1 )
uusiGenericFunc ( Ikä2 )
}
Aiemmassa lähdekoodissa määritimme 'EmpAge'-nimisen käyttöliittymän, joka määrittelee mahdolliset tyypit työntekijän iän mukaan. Käyttöliittymä sisältää tyypit int64, int32, float32 ja float64. Tämä käyttöliittymä sallii 'yleisen'-funktion hyväksyä minkä tahansa näistä tyypeistä argumenttina. Sen jälkeen käytämme yleistä funktiota nimeltä newGenericFunc, joka ottaa emp_Age-parametrin yleisestä iästä, joka voi olla mikä tahansa tyyppi, joka täyttää EmpAge-rajapinnan. Funktion sisällä se muuntaa emp_Age:n int:ksi ja lisää sitä 1:llä kuvan osoittamalla tavalla.
Seuraavaksi määritetään kaksi muuttujaa, Ikä1 ja Ikä2, ja määritetään arvot 24 ja 25,5 vastaavasti pääfunktiossa. Sen jälkeen Ikä1 ja Ikä2 välitetään parametreina newGenericFunc-funktiolle, joka suoritetaan kahdesti. Tämän avulla ikää korotetaan yhdellä ja ne luovat päivitetyt arvot.
Seuraavissa kohdissa saatu tulos on käyttöliittymää käyttävän yleisen funktion iät:
Esimerkki 3: Golangin yleisen tietorakenteen käyttäminen
Lisäksi Go Generics antaa meille mahdollisuuden rakentaa yleisiä tietorakenteita, kuten pinoja, jonoja ja linkitettyjä luetteloita. Harkitse yleisen pinon käyttöönottoa seuraavassa:
tuonti 'fmt'tyyppi Pino [ T mikä tahansa ] [] T
func ( st * Pino [ T ]) Työntää ( kohde T ) {
st = liittää ( * st , kohde )
}
func ( st * Pino [ T ]) Pop () T {
jos vain ( * st ) == 0 {
paniikki ( 'Ei mitään pinossa' )
}
indeksi := vain ( * st ) - 1
kohde := ( * st )[ indeksi ]
* st = ( * st )[: indeksi ]
palata kohde
}
func pää () {
pino := Uusi ( Pino [ int ])
pino . Työntää ( 1 )
pino . Työntää ( 2 )
pino . Työntää ( 3 )
fmt . Println ( pino . Pop ())
fmt . Println ( pino . Pop ())
fmt . Println ( pino . Pop ())
}
Edellisessä koodissa on määritelty yleinen tyyppi nimeltä 'Stack', joka edustaa pinoa. T-paikkamerkki sallii pinon pitää minkä tahansa tyyppiset elementit. Pinotyyppi on toteutettu osana T-tyypin elementtejä. Tässä 'Stack'-tyypille on käytössä kaksi toimintoa: 'Push' ja 'Pop'. Push()-funktio vastaa elementtien lisäämisestä pinoon. Se ottaa argumenttialkion tyyppiä 'T' ja liittää sen taustalla olevaan siivuun append()-funktiolla.
Vaikka Pop()-funktio ottaa alkukomponentin pinosta ja palauttaa sen, se määrittää ensin, onko pino tyhjä, arvioimalla alla olevan siivun koon. Virheilmoitus lähetetään, jos pino näyttää olevan tyhjä, mikä aiheuttaa paniikkia. Muussa tapauksessa se hakee osion viimeisen elementin, poistaa sen pinosta leikkaamalla lohkon toiseksi viimeiseen elementtiin ja palauttaa poistetun kohteen.
Seuraavaksi uusi kokonaislukupino luodaan käyttämällä Stack[int]-syntaksia tämän koodin päätoiminnossa. Sen jälkeen 'Push'-menetelmää kutsutaan kolme kertaa kokonaislukujen 1, 2 ja 3 lisäämiseksi pinoon. 'Pop'-menetelmää kutsutaan kuitenkin kolme kertaa peräkkäin elementtien hakemiseksi ja tulostamiseksi pinosta.
Seuraava tulos osoittaa, että elementit poistetaan pinosta käänteisessä järjestyksessä:
Esimerkki 4: Golangin yleisten rajoitusten käyttäminen
Go tarjoaa myös mukautettuja rajoituksia, jotka mahdollistavat suuren joustavuuden ja määrittelevät erityisiä vaatimuksia yleisille rakenteille niiden sovellustarpeiden perusteella. Mukautettujen yleisten rajoitusten koodi esitetään seuraavassa esittelyä varten:
paketti päätuonti 'fmt'
tyyppi Numerot käyttöliittymä {
int64 | kellua64
}
func pää () {
FloatValue := [] kellua64 { 2 . 0 , 4 . 0 , 6 . 0 , 8 . 0 , 10 . 0 }
KokonaislukuArvo := [] int64 { 2 , 4 , 6 , 8 , 10 }
summa1 := yleinenSum ( FloatValue )
summa2 := yleinenSum ( KokonaislukuArvo
fmt . Println ( 'Sum of float64 :' , summa1 )
fmt . Println ( 'Sum of int64 :' , summa2 )
}
func yleinenSum [ n Numerot ]( numeroita [] n ) n {
oli Olen n
varten _ , yhdellä := alue numeroita {
summa += yhdellä
}
palata summa
}
Aiemmassa lähdekoodissa määritämme Numerics-rajapinnan 'Summa'-menetelmällä. Sitten luomme kaksi mukautettua tyyppiä, 'FloatValue' ja 'IntegerValue', jotka toteuttavat Numerics-käyttöliittymän tarjoamalla vastaavat 'Summa'-menetelmät. GenericSum-funktio pystyy nyt hyväksymään minkä tahansa tyyppiset lohkot, jotka täyttävät Numerics-käyttöliittymän. Toiminnon sisällä iteroimme elementtejä ja kutsumme 'Summa'-menetelmää summan laskemiseksi. Lopuksi pääfunktiossa luomme FloatValue- ja IntegerValue-osuudet ja välitämme ne genericSum()-funktiolle, joka laskee oikein kunkin siivun elementtien summan.
Odotettu tulos näkyy nyt seuraavassa näytössä:
Johtopäätös
Tutkimme joitain käytännön esimerkkejä Go-generisistä, jotka sisältävät yleisen tietorakenteen ja yleisen funktion luomisen, yleisen käyttöliittymän määrittämisen ja mukautetun tyyppirajoitteen käyttämisen. Nämä esimerkit osoittavat tehon ja joustavuuden, jonka geneeriset tuotteet tuovat Go-ohjelmointikieleen. Huomaa, että geneerisen koodin luominen kääntämisen aikana varmistaa tehokkaan binäärikoon ja käännösajat.