Exemple 1: Casting de tipus bàsic Golang
Comencem amb l'exemple del càsting directe i bàsic a Go perquè necessitem el càsting per modificar el tipus de variable, a qualsevol lloc.
paquet principalimportar (
'fmt'
)
func principal () {
era x int = 31
i := flotar64 ( x )
fmt . Println ( i )
}
Aquí, comencem amb la funció principal declarant una variable anomenada 'x' de tipus 'int' i assignar-la amb un valor de 31. Després, la variable 'y' es declara mitjançant l'operador d'assignació abreujada ':='. El tipus de 'y' es determina automàticament a partir de l'expressió del costat dret que és el resultat de convertir 'x' en un 'float64'. Així, en aquest programa, el valor de 'x' es converteix en un 'float64' i s'assigna a 'y'.
Els resultats que es recuperen del càsting bàsic a Go es mostren de la següent manera:
Exemple 2: Casting de tipus implícit Golang
No es permet el càsting de tipus implícit entre diferents tipus. Go imposa l'escriptura forta, la qual cosa significa que no podem assignar ni utilitzar directament un valor d'un tipus com a altre sense una conversió explícita. A continuació, intentem realitzar el càsting implícit que genera l'excepció per Go:
paquet principal
importar 'fmt'
func principal () {
era enter int = 9 . 08
fmt . Printf ( 'El nombre sencer és %g' , enter )
}
Aquí teniu el codi que comença amb la funció main() on es declara una variable 'enteger' amb el tipus 'int'. El valor que s'assigna a la variable 'entera' és 9,08, que és un nombre de coma flotant. Com que estem intentant assignar un valor de coma flotant directament a una variable entera, es produeix un error de desajust de tipus. A continuació, utilitzem la funció 'printf' del paquet 'fmt' per imprimir el valor de la variable 'enteger' mitjançant l'especificador de format '%g'.
Com era d'esperar, el càsting de tipus implícit no és acceptable a Golang. El càsting de tipus implícit anterior genera l'error següent:
Exemple 3: Casting de tipus explícit Golang
La conversió de tipus explícita ens permet convertir de manera segura els valors entre tipus compatibles mentre indiquem explícitament una intenció. Assegura que som conscients de la conversió de tipus i ajuda a prevenir els errors de tipus accidentals. Considereu el càsting explícit següent:
paquet principalimportar 'fmt'
func principal () {
era flotarVal flotar32 = 6 . 75
era intVal int = int ( flotarVal )
fmt . Printf ( 'El valor flotant és %g \n ' , flotarVal )
fmt . Printf ( 'El valor enter és %d' , intVal )
}
Aquí, es crea una variable 'floatVal' amb el tipus 'float32' i se li assigna el valor '6.75'. A continuació, es declara una variable 'intVal' amb el tipus 'int'. Per assignar el valor de floatVal a intVal, s'utilitza la conversió de tipus. Per transformar el floatVal en un valor enter, la funció 'int' s'utilitza amb floatVal com a entrada. Després d'això, 'fmt.Printf('El valor flotant és %g\n', floatVal)' imprimeix el valor de floatVal utilitzant l'especificador de format %g que és adequat per imprimir els valors de coma flotant. Mentre que la línia de codi 'fmt.Printf('El valor enter és %d', intVal)' imprimeix el valor d'intVal utilitzant l'especificador de format %d que és adequat per imprimir els valors enters.
La sortida següent genera els valors tant per a floatVal com per a intVal després de llançar-lo:
Exemple 4: Casting tipus Golang per obtenir la mitjana
A continuació, realitzem el càsting per obtenir el nombre mitjà dels valors donats. Repassem el codi font que es proporciona a continuació:
paquet principalimportar 'fmt'
func principal () {
era total int = 900
era El meu número int = 20
era mitjana flotar32
mitjana = flotar32 ( total ) / flotar32 ( El meu número )
fmt . Printf ( 'La mitjana és = %f \n ' , mitjana )
}
Aquí, inicialment declarem tres variables. El 'total' és una variable entera que s'inicialitza amb el valor de 900. El 'MyNumber' és una variable entera que s'inicializa amb el valor de 20. La mitjana calculada s'emmagatzema a la variable 'mitjana' float32. A continuació, es dóna la fórmula mitjana per dur a terme el càlcul. Per garantir que la divisió es fa com una divisió de coma flotant, els valors de 'total' i 'MyNumber' es converteixen a float32 mitjançant la conversió de tipus. La mitjana calculada s'assigna a la variable 'mitjana'. Finalment, la cadena de format '%f\n' que s'utilitza a la funció 'printf' especifica que s'ha d'imprimir un valor flotant, seguit d'un caràcter de nova línia.
El valor resultant com a mitjana s'obté després d'implicar el tipus de càsting al codi anterior:
Exemple 5: Casting de tipus Golang Int i String
A més, Go també ofereix càsting entre els tipus Int i String. Ho podem aconseguir utilitzant la funció del paquet strconv.
paquet principalimportar (
'fmt'
'strconv'
)
func principal () {
era str corda = '1999'
en , _ := strconv . tràiler ( s )
fmt . Println ( en )
era enter int = 1999
aStr := strconv . ofegat ( enter )
fmt . Println ( aStr )
}
Aquí teniu el codi que comença amb la declaració de dues variables. La 'str' és una variable de cadena que s'inicialitza amb el valor de '1999' i el 'enteger' és una variable entera que s'inicialitza amb el valor de '1999'. Després d'això, la funció 'strconv.Atoi()' s'utilitza per convertir la cadena 'str' en un valor enter. El valor retornat de 'v' representa l'enter convertit i l'identificador '_' en blanc s'utilitza per ignorar qualsevol error potencial que retorni Atoi().
A continuació, s'utilitza la funció strconv.Itoa() per transformar l'enter en un valor de cadena. El valor retornat que és 'toStr' representa la cadena convertida.
La sortida mostra la conversió de la cadena '1999' a un nombre enter i de nou a una cadena que produeix el valor original de '1999':
Exemple 6: Casting de tipus Golang entre cadena i bytes
A més, el càsting a Go també es pot realitzar en tipus de cadena i byte. Els codis següents mostren la conversió entre cadenes i porcions de bytes:
paquet principalimportar (
'fmt'
)
func principal () {
era mystr corda = 'Hola'
era b1 [] byte = [] byte ( myStr )
fmt . Println ( b1 )
toString := corda ( b1 )
fmt . Println ( toString )
}
Aquí, les variables es declaren primer com a 'myStr' i 'b1' que s'inicien amb certs valors. A continuació, l'expressió []byte(myStr) converteix la cadena 'myStr' en una porció de bytes mitjançant la conversió de tipus. Assigna la porció de bytes resultant a la variable 'b1'. Després d'això, l'expressió 'cadena(b1)' torna a convertir la porció de bytes b1 en una cadena mitjançant la conversió de tipus. Assigna la cadena resultant a la variable 'toString'.
La sortida mostra la conversió entre la cadena 'Hey There' i la seva corresponent representació de la porció de bytes a continuació:
Exemple 7: Casting tipus Golang per obtenir l'arrel quadrada
Ara, fem el càsting a Go per trobar els resultats de l'arrel quadrada. El codi es col·loca de la següent manera:
paquet principalimportar (
'fmt'
'matemàtiques'
)
func principal () {
era n int = 177
era SqrtN flotar64
SqrtN = matemàtiques . Sqrt ( flotar64 ( n ))
fmt . Printf ( 'L'arrel quadrada de %d és %.2f \n ' , n , SqrtN )
}
Aquí, la variable 'n' es declara com a int i assigna el valor de '144'. La variable 'SqrtN' es declara com a float64 i emmagatzema l'arrel quadrada calculada de 'n'. A continuació, es desplega la funció math.Sqrt() per calcular l'arrel quadrada de “n”. Com que math.Sqrt() espera un argument float64 i el valor de “n” es converteix en float64 mitjançant float64(n). Després d'això, la cadena de format 'Arrel quadrada de %d és %.2f\n' crida a la funció 'printf' que especifica un valor enter (%d) i un valor de coma flotant (%.2f). L'especificador de precisió '.2' a '%.2f' garanteix que l'arrel quadrada s'imprimeixi amb dos decimals.
S'obté la sortida següent que indica l'arrel quadrada del valor donat:
Conclusió
El càsting a Go es parla amb exemples diferents que són tots executables. Tingueu en compte que a Go, l'escriptura de tipus és explícita, la qual cosa imposa una mecanografia forta i promou la claredat i la fiabilitat del codi.