Wat nog belangrijker is, generieke geneesmiddelen behouden Go's sterke typeveiligheid die statische typecontrole tijdens het compileren mogelijk maakt en de typecorrectheid garandeert. Ze bieden een gestandaardiseerde foutafhandeling binnen generieke code die de duidelijkheid en onderhoudbaarheid verbetert. Bovendien bieden ze een gestandaardiseerde foutafhandeling binnen de generieke code, wat de duidelijkheid en onderhoudbaarheid verbetert. In dit bericht zullen we de verschillende real-world Go-generieke toepassingen en voorbeelden onderzoeken.
Voorbeeld 1: de generieke Golang-functie gebruiken
Een van de belangrijkste use-cases voor generieke geneesmiddelen is het maken van functies die op verschillende typen kunnen werken. Hier gaan we met een van de voorbeelden waarin de generieke omtrekfunctie wordt gebruikt.
pakket voornaamst
importeren 'fmt'
func omtrek [ R int | vlotter32 ]( straal r ) {
C := 3 * 2 * straal
fmt . Println ( 'De algemene omtrek is: ' , C )
}
func voornaamst () {
was r1 int = 7
was r2 vlotter32 = 7 . 5
omtrek ( r1 )
omtrek ( r2 )
}
Aan het begin van de vorige code importeert de regel het 'fmt' -pakket dat functies biedt voor geformatteerde I / O, inclusief het afdrukken van de uitvoer naar de console. Vervolgens definiëren we een generieke functie met de naam 'circumference' die een parameterradius van een generiek type 'r' heeft, wat een 'int' of een 'float32' kan zijn. Binnen de functie berekent het de omtrek door de straal te vermenigvuldigen met de constante waarde van '3' en deze vervolgens te vermenigvuldigen met '2'. Ten slotte drukt het de berekende omtrek af met 'fmt.Println'.
Vervolgens hebben we de hoofdfunctie waarbij twee variabelen, r1 en r2, worden gedeclareerd en toegewezen met respectievelijk de waarden 7 en 7,5. Daarna wordt de functie 'omtrek' tweemaal aangeroepen, waarbij r1 en r2 als argumenten worden doorgegeven.
De uitvoer geeft de berekening weer door de omtrek van de cirkels als volgt af te drukken:
Voorbeeld 2: gebruik van de generieke Golang-interface
Bovendien helpen generieke Golang-generieken ons met hun interfaces. Interfaces in Go zijn een essentieel hulpmiddel om hergebruik van code en polymorfisme te vergemakkelijken. Door ze met vele typen te laten functioneren, vergroten generieke geneesmiddelen de kracht van interfaces. Het volgende is de broncode van de generische interface van Golang:
pakket voornaamst
importeren 'fmt'
type EmpAge koppel {
int64 | int32 | vlotter32 | vlotter64
}
func nieuwGenericFunc [ leeftijd Leeftijd ]( emp_Age leeftijd ) {
val := int ( emp_Age ) + 1
fmt . Println ( val )
}
func voornaamst () {
fmt . Println ( 'Leeftijd van werknemers' )
was Leeftijd1 int64 = 24
was Leeftijd2 vlotter64 = 25 . 5
nieuwGenericFunc ( Leeftijd1 )
nieuwGenericFunc ( Leeftijd2 )
}
In de vorige broncode hebben we een interface met de naam 'EmpAge' gedefinieerd die de mogelijke typen voor de leeftijd van een werknemer specificeert. De interface bevat de typen int64, int32, float32 en float64. Met deze interface kan de 'algemene' functie elk van deze typen als argument accepteren. Daarna gebruiken we een generieke functie met de naam newGenericFunc die de parameter emp_Age gebruikt van een generiek leeftijdstype dat elk type kan zijn dat voldoet aan de EmpAge-interface. Binnen de functie converteert het de emp_Age naar een int en verhoogt het met 1 zoals weergegeven.
Vervolgens declareren we de twee variabelen, Age1 en Age2, en wijzen we de waarden van respectievelijk 24 en 25,5 toe in de hoofdfunctie. Daarna worden Age1 en Age2 als parameters doorgegeven aan de functie newGenericFunc, die tweemaal wordt uitgevoerd. Hiermee worden de leeftijden met 1 verhoogd en worden de bijgewerkte waarden gegenereerd.
De uitvoer die wordt verkregen in het volgende zijn de leeftijden van de generieke functie die de interface gebruikt:
Voorbeeld 3: gebruik van de generieke gegevensstructuur van Golang
Bovendien geeft Go generics ons ook de mogelijkheid om de generieke datastructuren zoals stapels, wachtrijen en gekoppelde lijsten te bouwen. Overweeg de implementatie van de generieke stapel in het volgende:
importeren 'fmt'type Stapel [ T geen ] [] T
func ( st * Stapel [ T ]) Duw ( artikel T ) {
st = toevoegen ( * st , item )
}
func ( st * Stapel [ T ]) Knal () T {
als alleen ( * st ) == 0 {
paniek ( 'Niets in stapel' )
}
inhoudsopgave := alleen ( * st ) - 1
item := ( * st )[ inhoudsopgave ]
* st = ( * st )[: inhoudsopgave ]
opbrengst item
}
func voornaamst () {
stapel := nieuw ( Stapel [ int ])
stapel . Duw ( 1 )
stapel . Duw ( 2 )
stapel . Duw ( 3 )
fmt . Println ( stapel . Knal ())
fmt . Println ( stapel . Knal ())
fmt . Println ( stapel . Knal ())
}
In de vorige code is een generiek type met de naam 'Stack' gedefinieerd dat de stapel vertegenwoordigt. Met de tijdelijke aanduiding 'T' kan de stapel de elementen van elk type bevatten. Het type 'Stack' is geïmplementeerd als een segment van elementen van het type 'T'. Hier worden twee functies ingezet voor het type 'Stack': 'Push' en 'Pop'. De functie Push() is verantwoordelijk voor het toevoegen van de elementen aan de stapel. Het neemt een argumentitem van het type 'T' en voegt het toe aan het onderliggende segment met behulp van de functie append().
Hoewel de functie Pop() de eerste component uit de stapel haalt en retourneert, bepaalt deze eerst of de stapel leeg is door de grootte van het onderliggende segment te evalueren. Er wordt een foutmelding gestuurd als de stapel leeg blijkt te zijn waardoor er paniek ontstaat. Anders haalt het het laatste element uit het segment op, verwijdert het van de stapel door het segment op te splitsen tot het voorlaatste element en retourneert het verwijderde item.
Vervolgens wordt de nieuwe stapel gehele getallen gemaakt met behulp van de Stack[int]-syntaxis binnen de hoofdfunctie van deze code. Daarna wordt de 'Push' -methode driemaal aangeroepen om de gehele getallen 1, 2 en 3 aan de stapel toe te voegen. De 'Pop'-methode wordt echter drie keer achter elkaar aangeroepen om de elementen uit de stapel op te halen en af te drukken.
De volgende uitvoer geeft aan dat de elementen in omgekeerde volgorde van de stapel worden verwijderd:
Voorbeeld 4: Gebruik van de Golang Generic Constraints
Go biedt ook aangepaste beperkingen die een grote flexibiliteit mogelijk maken en specifieke vereisten definiëren voor generieke constructies op basis van hun toepassingsbehoeften. De code van de aangepaste generieke beperkingen wordt hieronder ter demonstratie gegeven:
pakket voornaamstimporteren 'fmt'
type Numeriek koppel {
int64 | vlotter64
}
func voornaamst () {
FloatWaarde := [] vlotter64 { 2 . 0 , 4 . 0 , 6 . 0 , 8 . 0 , 10 . 0 }
Integere waarde := [] int64 { 2 , 4 , 6 , 8 , 10 }
som1 := generiekSom ( FloatWaarde )
som2 := generiekSom ( Integere waarde
fmt . Println ( 'Som van float64 :' , som1 )
fmt . Println ( 'Som van int64 :' , som2 )
}
func generiekSom [ n Numeriek ]( nummers [] N ) N {
was Ik ben n
voor _ , op een := bereik nummers {
som += op een
}
opbrengst som
}
In de eerdere broncode definiëren we de Numerics-interface met de 'Sum' -methode. Vervolgens maken we twee aangepaste typen, 'FloatValue' en 'IntegerValue', die de Numerics-interface implementeren door hun respectieve 'Sum'-methoden te bieden. De functie genericSum kan nu de segmenten accepteren van elk type dat voldoet aan de Numerics-interface. Binnen de functie herhalen we de elementen en roepen we de 'Sum'-methode aan om de som te berekenen. Ten slotte maken we in de hoofdfunctie de segmenten van FloatValue en IntegerValue en geven deze door aan de functie genericSum() die de som van de elementen in elk segment correct berekent.
De verwachte uitvoer is nu zichtbaar op het volgende scherm:
Conclusie
We hebben enkele praktische voorbeelden van Go-generieken onderzocht, waaronder het maken van een generieke gegevensstructuur en generieke functie, het definiëren van een generieke interface en het gebruik van de aangepaste typebeperking. Deze voorbeelden demonstreren de kracht en flexibiliteit die generieke geneesmiddelen bieden aan de Go-programmeertaal. Merk op dat het genereren van generieke code tijdens het compileren zorgt voor een efficiënte binaire grootte en compilatietijden.