Eksempel 1: Golang Basic Type Casting
Lad os begynde med eksemplet med direkte og grundlæggende casting i Go, fordi vi kræver typecasting for at ændre typen af variablen, hvor som helst.
pakke vigtigsteimportere (
'fmt'
)
func vigtigste () {
var x int = 31
og := flyde 64 ( x )
fmt . Udskrivln ( og )
}
Her begynder vi med hovedfunktionen ved at erklære en variabel ved navn 'x' af typen 'int' og tildele den en værdi på 31. Derefter erklæres variablen 'y' ved hjælp af stenografi-tildelingsoperatoren ':='. Typen af 'y' bestemmes automatisk ud fra udtrykket på højre side, som er resultatet af at konvertere 'x' til en 'float64'. Så i dette program konverteres værdien af 'x' til en 'float64' og tildeles 'y'.
Resultaterne, der hentes fra den grundlæggende casting i Go, vises som følger:
Eksempel 2: Golang Implicit Type Casting
Implicit type casting er ikke tilladt mellem forskellige typer. Go gennemtvinger stærk indtastning, hvilket betyder, at vi ikke direkte kan tildele eller bruge en værdi af én type som en anden type uden eksplicit konvertering. I det følgende forsøger vi at udføre den implicitte casting, som genererer undtagelsen af Go:
pakke vigtigste
importere 'fmt'
func vigtigste () {
var heltal int = 9 . 08
fmt . Printf ( 'Heltal er %g' , heltal )
}
Her er koden, der begynder med main()-funktionen, hvor en 'heltals'-variabel er erklæret med typen 'int'. Værdien, der er tildelt 'heltals'-variablen, er 9,08, som er et flydende kommatal. Da vi forsøger at tildele en flydende kommaværdi direkte til en heltalsvariabel, resulterer det i en typemismatch-fejl. Derefter bruger vi 'printf'-funktionen fra 'fmt'-pakken til at udskrive værdien af 'heltal'-variablen ved hjælp af '%g'-formatspecifikationen.
Som forventet er den implicitte typestøbning ikke acceptabel i Golang. Den tidligere implicitte type casting genererer følgende fejl:
Eksempel 3: Golang eksplicit type casting
Den eksplicitte typekonvertering gør os i stand til sikkert at konvertere værdierne mellem kompatible typer, mens vi udtrykkeligt angiver en hensigt. Det sikrer, at vi er opmærksomme på typekonverteringen og hjælper med at forhindre utilsigtede typefejl. Overvej følgende eksplicitte casting:
pakke vigtigsteimportere 'fmt'
func vigtigste () {
var floatVal flyde 32 = 6 . 75
var intVal int = int ( floatVal )
fmt . Printf ( 'Floatværdi er %g \n ' , floatVal )
fmt . Printf ( 'Heltalsværdi er %d' , intVal )
}
Her oprettes en 'floatVal'-variabel med typen 'float32', og den tildeles værdien '6.75'. Derefter erklæres en 'intVal'-variabel med typen 'int'. For at tildele værdien af floatVal til intVal, bruges typekonverteringen. For at transformere floatVal til en heltalsværdi, bruges 'int'-funktionen med floatVal som input. Derefter udskriver 'fmt.Printf('Float Value is %g\n', floatVal)' værdien af floatVal ved hjælp af %g-formatspecifikationen, som er egnet til at udskrive flydende kommaværdier. Mens kodelinjen 'fmt.Printf('Integer Value is %d', intVal)' udskriver værdien af intVal ved hjælp af %d-formatspecifikationen, som er egnet til at udskrive heltalværdierne.
Følgende output genererer værdierne for både floatVal og intVal efter casting:
Eksempel 4: Golang-type casting for at få gennemsnittet
Dernæst udfører vi støbningen for at få det gennemsnitlige antal ud fra de givne værdier. Lad os gennemgå kildekoden, der er angivet i følgende:
pakke vigtigsteimportere 'fmt'
func vigtigste () {
var Total int = 900
var Mit nummer int = tyve
var gennemsnit flyde 32
gennemsnit = flyde 32 ( Total ) / flyde 32 ( Mit nummer )
fmt . Printf ( 'Gennemsnit er = %f \n ' , gennemsnit )
}
Her erklærer vi indledningsvis tre variable. 'Total' er en heltalsvariabel, der initialiseres med værdien 900. 'MyNumber' er en heltalsvariabel, der initialiseres med værdien 20. Det beregnede gennemsnit gemmes derefter i float32 'gennemsnit'-variablen. Derefter gives gennemsnitsformlen for at udføre beregningen. For at sikre at divisionen udføres som en floating-point division, konverteres værdierne af 'total' og 'MyNumber' til float32 ved hjælp af typekonverteringen. Det beregnede gennemsnit tildeles den 'gennemsnitlige' variabel. Endelig angiver '%f\n'-formatstrengen, der bruges i 'printf'-funktionen, at en flydende værdi skal udskrives, efterfulgt af et linjeskifttegn.
Den resulterende værdi som gennemsnit hentes efter at have antydet typestøbningen i den foregående kode:
Eksempel 5: Golang Int og String Type Casting
Derudover tilbyder Go også casting mellem Int og String typer. Vi kan opnå dette ved at bruge funktionen af strconv-pakken.
pakke vigtigsteimportere (
'fmt'
'strconv'
)
func vigtigste () {
var str snor = '1999'
i , _ := strconv . anhænger ( s )
fmt . Udskrivln ( i )
var heltal int = 1999
tilStr := strconv . druknede ( heltal )
fmt . Udskrivln ( tilStr )
}
Her er koden, der begynder med erklæringen af to variable. 'str' er en strengvariabel, der initialiseres med værdien '1999', og 'heltal' er en heltalsvariabel, der initialiseres med værdien '1999'. Derefter bruges 'strconv.Atoi()'-funktionen til at konvertere 'str'-strengen til en heltalsværdi. Den returnerede værdi af 'v' repræsenterer det konverterede heltal, og den tomme '_' identifikator bruges til at ignorere enhver potentiel fejl, der returneres af Atoi().
Dernæst bruges strconv.Itoa()-funktionen til at transformere hele tallet til en strengværdi. Den returnerede værdi, som er 'toStr', repræsenterer den konverterede streng.
Outputtet viser konverteringen fra '1999'-strengen til et heltal og tilbage til en streng, der producerer den oprindelige værdi af '1999':
Eksempel 6: Golang Type-casting mellem streng og bytes
Desuden kan castingen i Go også udføres i streng- og bytetyper. Følgende koder demonstrerer konverteringen mellem strenge og byteudsnit:
pakke vigtigsteimportere (
'fmt'
)
func vigtigste () {
var mystr snor = 'Hej med dig'
var b1 [] byte = [] byte ( myStr )
fmt . Udskrivln ( b1 )
til String := snor ( b1 )
fmt . Udskrivln ( til String )
}
Her er variablerne først erklæret som 'myStr' og 'b1', som initialiseres med bestemte værdier. Derefter konverterer []byte(myStr)-udtrykket 'myStr'-strengen til et byte-udsnit ved hjælp af typekonverteringen. Den tildeler den resulterende byte-slice til 'b1'-variablen. Derefter konverterer 'streng(b1)'-udtrykket byteudsnittet b1 tilbage til en streng ved hjælp af typekonverteringen. Den tildeler den resulterende streng til variablen 'toString'.
Outputtet viser konverteringen mellem 'Hey There'-strengen og dens tilsvarende byte-slice-repræsentation i følgende:
Eksempel 7: Golang Type-casting for at få kvadratroden
Nu laver vi støbningen i Go for at finde kvadratrodsresultaterne. Koden er placeret som følger:
pakke vigtigsteimportere (
'fmt'
'matematik'
)
func vigtigste () {
var n int = 177
var SqrtN flyde 64
SqrtN = matematik . Sqrt ( flyde 64 ( n ))
fmt . Printf ( 'Kvadratroden af %d er %.2f \n ' , n , SqrtN )
}
Her er 'n'-variablen erklæret som en int og tildeler værdien '144'. Variablen 'SqrtN' er deklareret som en float64 og gemmer den beregnede kvadratrod af 'n'. Derefter implementeres funktionen math.Sqrt() til at beregne kvadratroden af 'n'. Da math.Sqrt() forventer et float64-argument, og værdien af 'n' konverteres til float64 ved hjælp af float64(n). Derefter kalder 'Kvadratroden af %d er %.2f\n'-formatstrengen 'printf'-funktionen, som specificerer en heltalværdi (%d) og en flydende kommaværdi (%.2f). Præcisionsspecifikationen '.2' i '%.2f' sikrer, at kvadratroden udskrives med to decimaler.
Følgende output hentes, som angiver kvadratroden af den givne værdi:
Konklusion
Castingen i Go diskuteres med særskilte eksempler, som alle er eksekverbare. Husk på, at i Go er typecasting eksplicit, hvilket gennemtvinger stærk indtastning og fremmer kodeklarhed og pålidelighed.