Eksempel 1: Golang Basic Type Casting
La oss begynne med eksemplet med direkte og grunnleggende casting i Go fordi vi krever typecasting for å endre typen av variabelen, hvor som helst.
pakke hoved-import (
'fmt'
)
func hoved- () {
var x int = 31
og := flyte64 ( x )
fmt . Println ( og )
}
Her begynner vi med hovedfunksjonen ved å deklarere en variabel kalt 'x' av typen 'int' og tilordne den en verdi på 31. Deretter erklæres variabelen 'y' ved å bruke stenografi-tilordningsoperatoren ':='. Typen 'y' bestemmes automatisk fra uttrykket på høyre side som er resultatet av å konvertere 'x' til en 'float64'. Så i dette programmet blir verdien av 'x' konvertert til en 'float64' og tilordnet 'y'.
Resultatene som er hentet fra den grunnleggende castingen i Go, vises som følger:
Eksempel 2: Golang implisitt type casting
Implisitt type støping er ikke tillatt mellom ulike typer. Go håndhever sterk skriving som betyr at vi ikke direkte kan tildele eller bruke en verdi av en type som en annen type uten eksplisitt konvertering. I det følgende prøver vi å utføre den implisitte castingen som genererer unntaket av Go:
pakke hoved-
import 'fmt'
func hoved- () {
var heltall int = 9 . 08
fmt . Printf ( 'Heltall er %g' , heltall )
}
Her er koden som begynner med hoved()-funksjonen der en 'heltall'-variabel er deklarert med typen 'int'. Verdien som er tilordnet 'heltalls'-variabelen er 9,08 som er et flyttall. Siden vi prøver å tilordne en flyttallsverdi direkte til en heltallsvariabel, resulterer det i en typefeil. Deretter bruker vi 'printf'-funksjonen fra 'fmt'-pakken for å skrive ut verdien av 'heltall'-variabelen ved å bruke '%g'-formatspesifikasjonen.
Som forventet er den implisitte typen støping ikke akseptabel i Golang. Den forrige implisitte castingen genererer følgende feil:
Eksempel 3: Golang eksplisitt type casting
Den eksplisitte typekonverteringen gjør det mulig for oss å konvertere verdiene mellom kompatible typer på en sikker måte, samtidig som vi uttrykkelig angir en intensjon. Det sikrer at vi er klar over typekonverteringen og bidrar til å forhindre utilsiktede typefeil. Vurder følgende eksplisitte casting:
pakke hoved-import 'fmt'
func hoved- () {
var floatVal flyte32 = 6 . 75
var intVal int = int ( floatVal )
fmt . Printf ( 'Flytverdi er %g \n ' , floatVal )
fmt . Printf ( 'Heltallsverdi er %d' , intVal )
}
Her opprettes en 'floatVal'-variabel med typen 'float32', og den tildeles verdien '6.75'. Deretter er en 'intVal'-variabel deklarert med 'int'-typen. For å tilordne verdien av floatVal til intVal, brukes typekonverteringen. For å transformere floatVal til en heltallsverdi, brukes 'int'-funksjonen med floatVal som inngang. Deretter skriver 'fmt.Printf('Flytverdi er %g\n', floatVal)' ut verdien av floatVal ved å bruke %g-formatspesifikasjonen som er egnet for å skrive ut flyttallverdiene. Mens kodelinjen 'fmt.Printf('Integer Value is %d', intVal)' skriver ut verdien av intVal ved å bruke %d-formatspesifikasjonen som er egnet for å skrive ut heltallsverdiene.
Følgende utgang genererer verdiene for både floatVal og intVal etter casting:
Eksempel 4: Golang-type casting for å få gjennomsnittet
Deretter utfører vi støpingen for å få gjennomsnittstall fra de gitte verdiene. La oss gå gjennom kildekoden som er gitt i følgende:
pakke hoved-import 'fmt'
func hoved- () {
var Total int = 900
var Nummeret mitt int = tjue
var gjennomsnitt flyte32
gjennomsnitt = flyte32 ( Total ) / flyte32 ( Nummeret mitt )
fmt . Printf ( 'Gjennomsnitt er = %f \n ' , gjennomsnitt )
}
Her erklærer vi innledningsvis tre variabler. 'Total' er en heltallsvariabel som initialiseres med verdien 900. 'MyNumber' er en heltallsvariabel som initialiseres med verdien 20. Det beregnede gjennomsnittet lagres deretter i float32 'gjennomsnittlig' variabel. Gjennomsnittsformelen gis deretter for å utføre beregningen. For å sikre at divisjonen gjøres som en flyttallsdivisjon, konverteres verdiene for 'total' og 'Mitt tall' til flyte32 ved å bruke typekonverteringen. Det beregnede gjennomsnittet tilordnes den 'gjennomsnittlige' variabelen. Til slutt spesifiserer '%f\n'-formatstrengen som brukes i 'printf'-funksjonen at en flytende verdi skal skrives ut, etterfulgt av et linjeskifttegn.
Den resulterende verdien som gjennomsnitt hentes etter å ha antydet typen avstøpning i forrige kode:
Eksempel 5: Golang Int og String Type Casting
I tillegg tilbyr Go også casting mellom Int- og String-typer. Vi kan oppnå dette ved å bruke funksjonen til strconv-pakken.
pakke hoved-import (
'fmt'
'strconv'
)
func hoved- () {
var str streng = '1999'
i , _ := strconv . tilhenger ( s )
fmt . Println ( i )
var heltall int = 1999
tilStr := strconv . druknet ( heltall )
fmt . Println ( tilStr )
}
Her er koden som begynner med erklæringen av to variabler. 'str' er en strengvariabel som initialiseres med verdien '1999' og 'heltal' er en heltallsvariabel som initialiseres med verdien '1999'. Etter det brukes 'strconv.Atoi()'-funksjonen til å konvertere 'str'-strengen til en heltallsverdi. Den returnerte verdien av 'v' representerer det konverterte heltall, og den tomme '_'-identifikatoren brukes til å ignorere enhver potensiell feil som returneres av Atoi().
Deretter brukes strconv.Itoa()-funksjonen for å transformere heltallet til en strengverdi. Den returnerte verdien som er 'toStr' representerer den konverterte strengen.
Utdataene viser konverteringen fra '1999'-strengen til et heltall og tilbake til en streng som produserer den opprinnelige verdien av '1999':
Eksempel 6: Golang Type casting mellom streng og byte
Dessuten kan castingen i Go også utføres i streng- og bytetyper. Følgende koder demonstrerer konverteringen mellom strenger og byteskiver:
pakke hoved-import (
'fmt'
)
func hoved- () {
var mystr streng = 'Hei der'
var b1 [] byte = [] byte ( myStr )
fmt . Println ( b1 )
til String := streng ( b1 )
fmt . Println ( til String )
}
Her blir variablene først erklært som 'myStr' og 'b1' som initialiseres med visse verdier. Deretter konverterer []byte(myStr)-uttrykket 'myStr'-strengen til en byte-del ved å bruke typekonverteringen. Den tildeler den resulterende byte-skiven til 'b1'-variabelen. Etter det konverterer 'streng(b1)'-uttrykket bytesnittet b1 tilbake til en streng ved å bruke typekonverteringen. Den tildeler den resulterende strengen til 'toString'-variabelen.
Utdataene viser konverteringen mellom 'Hey There'-strengen og dens korresponderende byte-representasjon i følgende:
Eksempel 7: Golang Type-casting for å få kvadratroten
Nå utfører vi støpingen i Go for å finne kvadratrotresultatene. Koden er plassert som følger:
pakke hoved-import (
'fmt'
'matte'
)
func hoved- () {
var n int = 177
var SqrtN flyte64
SqrtN = matte . Sqrt ( flyte64 ( n ))
fmt . Printf ( 'Kvadratroten av %d er %.2f \n ' , n , SqrtN )
}
Her er 'n'-variabelen deklarert som en int og tildeler verdien '144'. Variabelen 'SqrtN' er deklarert som en float64 og lagrer den beregnede kvadratroten av 'n'. Deretter brukes math.Sqrt()-funksjonen for å beregne kvadratroten av 'n'. Siden math.Sqrt() forventer et float64-argument, og verdien av “n” konverteres til float64 ved å bruke float64(n). Etter det kaller 'Kvadratroten av %d er %.2f\n'-formatstrengen 'printf'-funksjonen som spesifiserer en heltallsverdi (%d) og en flyttallsverdi (%.2f). Presisjonspesifikasjonen '.2' i '%.2f' sikrer at kvadratroten skrives ut med to desimaler.
Følgende utdata hentes som indikerer kvadratroten av den gitte verdien:
Konklusjon
Casting in Go er diskutert med distinkte eksempler som alle er kjørbare. Husk at i Go er typecasting eksplisitt som fremtvinger sterk skriving og fremmer kodeklarhet og pålitelighet.