Conversión de tipos en Go
La conversión de tipos se utiliza para convertir una variable de un tipo de datos a otro tipo.
El formato básico de la conversión de tipos en Go es el siguiente:
type_name(expression)
type_name es el tipo y expression es la expresión.
Conversión de tipos numéricos
Convertir un entero a punto flotante:
var b float64 = float64(a)
En el siguiente ejemplo, se convierte un entero a punto flotante, se calcula el resultado y se asigna el resultado a una variable de punto flotante:
Ejemplo
import "fmt"
func main() {
var sum int = 17
var count int = 5
var mean float32
mean = float32(sum)/float32(count)
fmt.Printf("El valor de mean es: %f\n",mean)
}
El resultado de ejecutar el ejemplo anterior es:
mean 的值为: 3.400000
Conversión de cadenas
Para convertir una cadena a otro tipo, se puede usar la siguiente sintaxis:
var str string = "10" var num int num, _ = strconv.Atoi(str)
El código anterior convierte la variable de cadena str en la variable entera num.
Nota:strconv.AtoiLa función devuelve dos valores: el primero es el valor entero convertido y el segundo es un posible error. Podemos usar el identificador en blanco_para ignorar este error.
。El siguiente ejemplo convierte una cadena a un entero:
Ejemplo
import (
"fmt"
"strconv"
)
func main() {
str := "123"
num, err := strconv.Atoi(str)
if err != nil {
fmt.Println("Error de conversión:", err)
} else {
fmt.Printf("La cadena '%s' convertida a entero es: %d\n", str, num)
}
}
El resultado de ejecutar el ejemplo anterior es:
字符串 '123' 转换为整数为:123
El siguiente ejemplo convierte un entero a una cadena:
Ejemplo
import (
"fmt"
"strconv"
)
func main() {
num := 123
str := strconv.Itoa(num)
fmt.Printf("El entero %d convertido a cadena es: '%s'\n", num, str)
}
El resultado de ejecutar el ejemplo anterior es:
整数 123 转换为字符串为:'123'
El siguiente ejemplo convierte una cadena a un número de punto flotante:
Ejemplo
import (
"fmt"
"strconv"
)
func main() {
str := "3.14"
num, err := strconv.ParseFloat(str, 64)
if err != nil {
fmt.Println("Error de conversión:", err)
} else {
fmt.Printf("La cadena '%s' convertida a punto flotante es: %f\n", str, num)
}
}
El resultado de ejecutar el ejemplo anterior es:
字符串 '3.14' 转为浮点型为:3.140000
El siguiente ejemplo convierte un número de punto flotante a una cadena:
Ejemplo
import (
"fmt"
"strconv"
)
func main() {
num := 3.14
str := strconv.FormatFloat(num, 'f', 2, 64)
fmt.Printf("El número de punto flotante %f convertido a cadena es: '%s'\n", num, str)
}
El resultado de ejecutar el ejemplo anterior es:
浮点数 3.140000 转为字符串为:'3.14'
Conversión de tipos de interfaz
La conversión de tipos de interfaz tiene dos casos: aserción de tipoyConversión de tipos。
Aserción de tipo
La aserción de tipo se utiliza para convertir un tipo de interfaz a un tipo específico. Su sintaxis es:
value.(type) 或者 value.(T)
Donde value es una variable de tipo interfaz, y type o T es el tipo al que se desea convertir.
Si la aserción de tipo tiene éxito, devuelve el valor convertido y un valor booleano que indica si la conversión fue exitosa.
Ejemplo
import "fmt"
func main() {
var i interface{} = "Hello, World"
str, ok := i.(string)
if ok {
fmt.Printf("'%s' is a string\n", str)
} else {
fmt.Println("conversion failed")
}
}
En el ejemplo anterior, definimos una variable de tipo interfaz i y le asignamos la cadena "Hello, World". Luego, usamos la aserción de tipo para convertir i al tipo cadena y asignamos el valor convertido a la variable str. Finalmente, usamos la variable ok para comprobar si la conversión de tipo fue exitosa; si lo fue, imprimimos la cadena convertida; de lo contrario, imprimimos un mensaje de error de conversión.
Conversión de tipos
La conversión de tipos se utiliza para convertir un valor de un tipo de interfaz a otro tipo de interfaz. Su sintaxis es:
T(value)
T es el tipo de interfaz de destino y value es el valor que se va a convertir.
En la conversión de tipos, debemos asegurarnos de que el valor a convertir y el tipo de interfaz de destino sean compatibles; de lo contrario, el compilador mostrará un error.
Ejemplo
import "fmt"
// Define una interfaz Writer
type Writer interface {
Write([]byte) (int, error)
}
// Estructura StringWriter que implementa la interfaz Writer
type StringWriter struct {
str string
}
// Implementa el método Write
func (sw *StringWriter) Write(data []byte) (int, error) {
sw.str += string(data)
return len(data), nil
}
func main() {
// Crea una instancia de StringWriter y la asigna a la variable de interfaz Writer
var w Writer = &StringWriter{}
// Convierte el tipo de interfaz Writer al tipo StringWriter
sw := w.(*StringWriter)
// Modifica el campo de StringWriter
sw.str = "Hello, World"
// Imprime el valor del campo de StringWriter
fmt.Println(sw.str)
}
Análisis:
Definir la interfaz y la estructura:
WriterLa interfaz defineWriteel método.StringWriterLa estructura implementaWriteel método.
Conversión de tipos:
- va a
StringWriterLa instancia se asigna aWritervariable de interfazw。 - Utilice
w.(*StringWriter)va aWriterla conversión del tipo de interfaz aStringWritertipo.
- va a
Acceso a campos:
- Modificar
StringWriterel campo destr, y imprimir su valor.
- Modificar
Tipo de interfaz vacía
Interfaz vacíainterface{}Puede contener valores de cualquier tipo. En la práctica, la interfaz vacía se utiliza a menudo para manejar valores de múltiples tipos.
Ejemplo
import (
"fmt"
)
func printValue(v interface{}) {
switch v := v.(type) {
case int:
fmt.Println("Integer:", v)
case string:
fmt.Println("String:", v)
default:
fmt.Println("Unknown type")
}
}
func main() {
printValue(42)
printValue("hello")
printValue(3.14)
}
En este ejemplo, la función printValue acepta un parámetro de tipo interfaz vacía y utiliza la aserción de tipo y la selección de tipo para manejar diferentes tipos.
Otras extensiones