Voorbeeld 1: Golang Basic Type Casting
Laten we beginnen met het voorbeeld van direct en basic casten in Go, omdat we typecasting nodig hebben om het type variabele overal te wijzigen.
pakket voornaamstimporteren (
'fmt'
)
func voornaamst () {
was X int = 31
En := vlotter64 ( X )
fmt . Println ( En )
}
Hier beginnen we met de hoofdfunctie door een variabele met de naam 'x' van het type 'int' te declareren en deze een waarde van 31 toe te wijzen. Vervolgens wordt de variabele 'y' gedeclareerd met behulp van de verkorte toewijzingsoperator ':='. Het type 'y' wordt automatisch bepaald uit de uitdrukking aan de rechterkant die het resultaat is van het converteren van 'x' naar een 'float64'. Dus in dit programma wordt de waarde van 'x' geconverteerd naar een 'float64' en toegewezen aan 'y'.
De resultaten die worden opgehaald uit de basiscasting in Go worden als volgt weergegeven:
Voorbeeld 2: Golang impliciete typecasting
Impliciete typecasting tussen verschillende typen is niet toegestaan. Go dwingt sterk typen af, wat betekent dat we een waarde van het ene type niet rechtstreeks kunnen toewijzen of gebruiken als een ander type zonder expliciete conversie. In het volgende proberen we de impliciete casting uit te voeren die de uitzondering door Go genereert:
pakket voornaamst
importeren 'fmt'
func voornaamst () {
was geheel getal int = 9 . 08
fmt . Printf ( 'Geheel getal is %g' , geheel getal )
}
Hier is de code die begint met de functie main() waarbij een variabele 'integer' wordt gedeclareerd met het type 'int'. De waarde die is toegewezen aan de variabele 'integer' is 9,08, wat een getal met drijvende komma is. Aangezien we proberen een drijvende-kommawaarde rechtstreeks toe te wijzen aan een variabele met een geheel getal, resulteert dit in een type-mismatch-fout. Vervolgens gebruiken we de 'printf' -functie van het 'fmt' -pakket om de waarde van de 'integer' -variabele af te drukken met behulp van de '%g' -formaatspecificatie.
Zoals verwacht is de impliciete typecasting niet acceptabel in Golang. De vorige impliciete typecasting genereert de volgende fout:
Voorbeeld 3: Golang Explicit Type Casting
De expliciete typeconversie stelt ons in staat om de waarden tussen compatibele typen veilig om te zetten terwijl we expliciet een intentie aangeven. Het zorgt ervoor dat we op de hoogte zijn van de typeconversie en helpt om onbedoelde typefouten te voorkomen. Overweeg de volgende expliciete casting:
pakket voornaamstimporteren 'fmt'
func voornaamst () {
was floatVal vlotter32 = 6 . 75
was intVal int = int ( floatVal )
fmt . Printf ( 'Floatwaarde is %g \N ' , floatVal )
fmt . Printf ( 'Geheel getal is %d' , intVal )
}
Hier wordt een variabele 'floatVal' gemaakt met het type 'float32' en krijgt de waarde '6.75' toegewezen. Vervolgens wordt een variabele 'intVal' gedeclareerd met het type 'int'. Om de waarde van floatVal toe te wijzen aan intVal, wordt de typeconversie gebruikt. Om de floatVal in een geheel getal om te zetten, wordt de functie 'int' gebruikt met floatVal als invoer. Daarna drukt de 'fmt.Printf('Float Value is %g\n', floatVal)' de waarde van floatVal af met behulp van de %g-formaatspecificatie die geschikt is voor het afdrukken van drijvende-kommawaarden. Terwijl de coderegel 'fmt.Printf ('Integer Value is %d', intVal)' de waarde van intVal afdrukt met behulp van de %d-indelingsspecificatie die geschikt is voor het afdrukken van de integer-waarden.
De volgende uitvoer genereert de waarden voor zowel de floatVal als de intVal nadat deze is gecast:
Voorbeeld 4: Golang Type Casting om het gemiddelde te krijgen
Vervolgens voeren we de casting uit om het gemiddelde aantal uit de gegeven waarden te halen. Laten we de broncode doornemen die hieronder wordt gegeven:
pakket voornaamstimporteren 'fmt'
func voornaamst () {
was totaal int = 900
was Mijn nummer int = twintig
was gemiddeld vlotter32
gemiddeld = vlotter32 ( totaal ) / vlotter32 ( Mijn nummer )
fmt . Printf ( 'Gemiddelde is = %f \N ' , gemiddeld )
}
Hier declareren we in eerste instantie drie variabelen. De 'totaal' is een integer-variabele die wordt geïnitialiseerd met de waarde 900. De 'MyNumber' is een integer-variabele die wordt geïnitialiseerd met de waarde 20. Het berekende gemiddelde wordt vervolgens opgeslagen in de float32 'gemiddelde' variabele. Vervolgens wordt de gemiddelde formule gegeven om de berekening uit te voeren. Om ervoor te zorgen dat de deling wordt uitgevoerd als een deling met drijvende komma, worden de waarden van 'totaal' en 'MijnGetal' geconverteerd naar float32 met behulp van de typeconversie. Het berekende gemiddelde wordt toegewezen aan de variabele 'gemiddelde'. Ten slotte specificeert de '%f\n'-indelingsreeks die wordt gebruikt in de 'printf'-functie dat een float-waarde moet worden afgedrukt, gevolgd door een teken voor een nieuwe regel.
De resulterende waarde als het gemiddelde wordt opgehaald nadat het type casting in de vorige code is geïmpliceerd:
Voorbeeld 5: Golang Int en String Type Casting
Daarnaast biedt Go ook casting tussen Int- en String-typen. We kunnen dit bereiken met behulp van de functie van het strconv-pakket.
pakket voornaamstimporteren (
'fmt'
'strconv'
)
func voornaamst () {
was str snaar = '1999'
in , _ := strconv . aanhangwagen ( S )
fmt . Println ( in )
was geheel getal int = 1999
naarStr := strconv . verdronken ( geheel getal )
fmt . Println ( naarStr )
}
Hier is de code die begint met de declaratie van twee variabelen. De 'str' is een stringvariabele die wordt geïnitialiseerd met de waarde '1999' en de 'integer' is een integer-variabele die wordt geïnitialiseerd met de waarde '1999'. Daarna wordt de functie 'strconv.Atoi()' gebruikt om de tekenreeks 'str' om te zetten in een geheel getal. De geretourneerde waarde van 'v' vertegenwoordigt het geconverteerde gehele getal en de blanco '_'-ID wordt gebruikt om mogelijke fouten te negeren die worden geretourneerd door Atoi().
Vervolgens wordt de functie strconv.Itoa() gebruikt om het gehele getal om te zetten in een tekenreekswaarde. De geretourneerde waarde die 'toStr' is, vertegenwoordigt de geconverteerde tekenreeks.
De uitvoer toont de conversie van de tekenreeks '1999' naar een geheel getal en terug naar een tekenreeks die de oorspronkelijke waarde van '1999' oplevert:
Voorbeeld 6: Casting van Golang-type tussen tekenreeks en bytes
Bovendien kan de casting in Go ook worden uitgevoerd in string- en bytetypes. De volgende codes demonstreren de conversie tussen strings en byte-slices:
pakket voornaamstimporteren (
'fmt'
)
func voornaamst () {
was mystr snaar = 'Hallo daar'
was b1 [] byte = [] byte ( mijnStr )
fmt . Println ( b1 )
naarString := snaar ( b1 )
fmt . Println ( naarString )
}
Hier worden de variabelen eerst gedeclareerd als 'myStr' en 'b1', die worden geïnitialiseerd met bepaalde waarden. Vervolgens converteert de uitdrukking []byte(myStr) de tekenreeks 'myStr' naar een bytesegment met behulp van de typeconversie. Het wijst het resulterende bytesegment toe aan de variabele 'b1'. Daarna converteert de uitdrukking 'string(b1)' de byte-slice b1 terug naar een string met behulp van de typeconversie. Het wijst de resulterende string toe aan de variabele 'toString'.
De uitvoer toont de conversie tussen de tekenreeks 'Hallo daar' en de overeenkomstige weergave van bytesegmenten in het volgende:
Voorbeeld 7: Golang Type Casting om de vierkantswortel te krijgen
Nu doen we de casting in Go om de vierkantswortelresultaten te vinden. De code is als volgt geplaatst:
pakket voornaamstimporteren (
'fmt'
'wiskunde'
)
func voornaamst () {
was N int = 177
was SqrtN vlotter64
SqrtN = wiskunde . Sqrt ( vlotter64 ( N ))
fmt . Printf ( 'Vierkantswortel van %d is %.2f \N ' , N , SqrtN )
}
Hier wordt de variabele 'n' gedeclareerd als een int en kent de waarde '144' toe. De variabele 'SqrtN' wordt gedeclareerd als een float64 en slaat de berekende vierkantswortel van 'n' op. Vervolgens wordt de functie math.Sqrt() ingezet om de vierkantswortel van 'n' te berekenen. Omdat math.Sqrt() een float64-argument verwacht en de waarde van 'n' wordt geconverteerd naar float64 met behulp van float64(n). Daarna wordt de tekenreeks 'Vierkantswortel van %d is %.2f\n' aangeroepen in de 'printf'-functie die een geheel getal (%d) en een drijvende-kommawaarde (%.2f) specificeert. De precisiespecificatie '.2' in '%.2f' zorgt ervoor dat de vierkantswortel wordt afgedrukt met twee decimalen.
De volgende uitvoer wordt opgehaald die de vierkantswortel van de opgegeven waarde aangeeft:
Conclusie
De casting in Go wordt besproken met duidelijke voorbeelden die allemaal uitvoerbaar zijn. Houd er rekening mee dat typecasting in Go expliciet is, wat sterk typen afdwingt en de duidelijkheid en betrouwbaarheid van de code bevordert.