Eksempler på generiske Golang

Endnu vigtigere er det, at generics opretholder Go's stærke typesikkerhed, som muliggør statisk typekontrol på kompileringstidspunktet og sikrer, at typen er korrekt. De giver en standardiseret fejlhåndtering inden for generisk kode, som forbedrer klarhed og vedligeholdelse. Derudover giver de en standardiseret fejlhåndtering inden for den generiske kode, som forbedrer klarheden og vedligeholdelsen. I dette indlæg vil vi undersøge de adskillige Go generiske applikationer og eksempler fra den virkelige verden.

Eksempel 1: Brug af den generelle Golang-funktion

Et af de primære anvendelsesmuligheder for generiske lægemidler er at skabe funktioner, der kan fungere på forskellige typer. Her går vi med et af eksemplerne, hvor den generiske omkredsfunktion bruges.

I begyndelsen af ​​den forrige kode importerer linjen 'fmt'-pakken, som giver funktioner til formateret I/O, inklusive udskrivning af output til konsollen. Derefter definerer vi en generisk funktion ved navn 'omkreds', der tager en parameterradius af en generisk type 'r', som enten kan være en 'int' eller en 'float32'. Inde i funktionen beregner den omkredsen ved at gange radius med den konstante værdi af '3' og derefter gange den med '2'. Til sidst udskriver den den beregnede omkreds ved hjælp af 'fmt.Println'.

Dernæst har vi hovedfunktionen, hvor to variable, r1 og r2, er deklareret og tildelt værdierne henholdsvis 7 og 7,5. Derefter aktiveres funktionen 'omkreds' to gange, idet r1 og r2 sendes som argumenter.

Outputtet viser beregningen ved at udskrive omkredsen af ​​cirklerne i følgende:

Eksempel 2:  Brug af Golang Generic Interface

Desuden hjælper Golang generika os med deres grænseflader. Grænseflader i Go er et vigtigt værktøj til at lette genbrug af kode og polymorfi. Ved at sætte dem i stand til at fungere med mange typer, øger generiske grænseflader kraften i grænseflader. Følgende er kildekoden til Golang generiske grænseflade:

I den tidligere kildekode definerede vi en grænseflade ved navn 'EmpAge', der specificerer de mulige typer for en medarbejders alder. Interfacet inkluderer typerne int64, int32, float32 og float64. Denne grænseflade tillader den 'generiske' funktion at acceptere enhver af disse typer som et argument. Derefter bruger vi en generisk funktion ved navn newGenericFunc, der tager parameteren emp_Age fra en generisk alderstype, som kan være enhver type, der opfylder EmpAge-grænsefladen. Inde i funktionen konverterer den emp_Age til en int og øger den med 1 som vist.

Dernæst erklærer vi de to variable, Alder1 og Alder2, og tildeler værdierne henholdsvis 24 og 25,5 i hovedfunktionen. Derefter sendes Age1 og Age2 som parametre til funktionen newGenericFunc, som gennemgår en eksekvering to gange. Hermed hæves alderen med 1 og genererer de opdaterede værdier.

Det output, der er givet i det følgende, er alderen fra den generiske funktion, der bruger grænsefladen:

Eksempel 3: Brug af Golangs generiske datastruktur

Desuden giver Go generics os også muligheden for at bygge de generiske datastrukturer som stakke, køer og linkede lister. Overvej implementeringen af ​​den generiske stak i følgende:

I den foregående kode er en generisk type med titlen 'Stack' defineret, som repræsenterer stakken. 'T' pladsholderen tillader stakken at indeholde elementer af enhver type. 'Stack'-typen er implementeret som et udsnit af elementer af typen 'T'. Her er to funktioner implementeret for 'Stack'-typen: 'Push' og 'Pop.' Funktionen Push() er ansvarlig for at tilføje elementerne til stakken. Det tager et argumentelement af typen 'T' og føjer det til det underliggende udsnit ved hjælp af append()-funktionen.

Mens funktionen Pop() tager den indledende komponent fra stakken og returnerer den, bestemmer den først, om stakken er tom ved at evaluere størrelsen af ​​den underliggende udsnit. En fejlmeddelelse sendes, hvis stakken ser ud til at være tom, hvilket forårsager panik. Ellers henter den det sidste element fra udsnittet, fjerner det fra stakken ved at skære udsnittet op til det næstsidste element og returnerer det fjernede element.

Dernæst oprettes den nye stak af heltal ved hjælp af Stack[int]-syntaksen inden for hovedfunktionen af ​​denne kode. Derefter kaldes 'Push'-metoden tre gange for at tilføje heltal 1, 2 og 3 til stakken. Men 'Pop'-metoden kaldes tre gange efterfølgende for at hente og printe elementerne fra stakken.

Følgende output indikerer, at elementerne fjernes fra stakken i omvendt rækkefølge:

Eksempel 4: Brug af Golang Generic Constraints

Go tilbyder også brugerdefinerede begrænsninger, der muliggør stor fleksibilitet og definerer specifikke krav til generiske konstruktioner baseret på deres applikationsbehov. Koden for de brugerdefinerede generiske begrænsninger er angivet i det følgende til demonstration:

I den tidligere kildekode definerer vi Numerics-grænsefladen med 'Sum'-metoden. Derefter opretter vi to brugerdefinerede typer, 'FloatValue' og 'IntegerValue', som implementerer Numerics-grænsefladen ved at levere deres respektive 'Sum'-metoder. GenericSum-funktionen er nu i stand til at acceptere udsnit af enhver type, der opfylder Numerics-grænsefladen. Inde i funktionen itererer vi over elementerne og kalder 'Sum'-metoden for at beregne summen. Til sidst, i hovedfunktionen, opretter vi skiverne af FloatValue og IntegerValue og sender dem til funktionen genericSum() som korrekt beregner summen af ​​elementerne i hver skive.

Det forventede output er nu synligt på følgende skærm:

Konklusion

Vi undersøgte nogle praktiske eksempler på Go-generics, som omfatter oprettelsen af ​​en generisk datastruktur og generisk funktion, definering af en generisk grænseflade og brug af den brugerdefinerede type-begrænsning. Disse eksempler demonstrerer den kraft og fleksibilitet, som generiske lægemidler tilfører programmeringssproget Go. Bemærk, at generering af generisk kode under kompilering sikrer den effektive binære størrelse og kompileringstider.