Revisión pasada:
- Go Language Tutorial – Introducción (1)
- Go Language Tutorial – Estructura del lenguaje (2)
- Go Language Tutorial – Estructura del lenguaje (3)
- Tutorial de Go Language: tipos de datos (4)
- Go Language Tutorial - Variables de idioma (5)
- Tutorial de idioma Go: constantes de idioma GO (6)
- Tutorial de idioma Go – Operadores de idioma GO (7)
- Tutorial de lenguaje Go: condiciones GO y sentencias de bucle (8)
- Tutorial de idioma Go: funciones del idioma GO (9)
- Tutorial de idioma Go – Ámbito variable de idioma GO (10)
- Tutorial de idiomas Go: matriz de idiomas GO (11)
- Tutorial de idioma Go – Puntero de idioma GO (12)
- Tutorial de idioma Go – Estructura del idioma GO (13)
- Go Language Tutorial – GO Language Slice (Slice) (14)
- Tutorial de idioma Go – Rango de idioma Go (Rango) (15)
- Go Language Tutorial – Go Language Map (Colección) (16)
- Tutorial de Go Language – Función recursiva de Go Language (17)
Directorio de artículos
La conversión de tipos se utiliza para convertir una variable de un tipo de datos en otro tipo de variable.
El formato básico de conversión de tipo de idioma de Go es el siguiente:
type_name(expression)
type_name es el tipo y expresión es la expresión.
Conversión de tipo numérico
Convierta un número entero en un flotante:
var a int = 10
var b float64 = float64(a)
En el siguiente ejemplo, el tipo entero se convierte en un tipo de punto flotante, el resultado se calcula y el resultado se asigna a una variable de tipo de punto flotante:
ejemplo
package main
import "fmt"
func main() {
var sum int = 17
var count int = 5
var mean float32
mean = float32(sum)/float32(count)
fmt.Printf("mean 的值为: %f\n",mean)
}
El resultado de la ejecución del ejemplo anterior es:
mean 的值为: 3.400000
Conversión de tipo de cadena
Para convertir una cadena a otro tipo, use 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.
Tenga en cuenta que la función strconv.Atoi 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 en un entero
ejemplo
package main
import (
"fmt"
"strconv"
)
func main() {
str := "123"
num, err := strconv.Atoi(str)
if err != nil {
fmt.Println("转换错误:", err)
} else {
fmt.Printf("字符串 '%s' 转换为整数为：%d\n", str, num)
}
}
El resultado de la ejecución del ejemplo anterior es:
字符串 '123' 转换为整数为：123
El siguiente ejemplo convierte un entero en una cadena:
ejemplo
package main
import (
"fmt"
"strconv"
)
func main() {
num := 123
str := strconv.Itoa(num)
fmt.Printf("整数 %d 转换为字符串为：'%s'\n", num, str)
}
El resultado de la ejecución del ejemplo anterior es:
整数 123 转换为字符串为：'123'
El siguiente ejemplo convierte una cadena en un flotante:
ejemplo
package main
import (
"fmt"
"strconv"
)
func main() {
str := "3.14"
num, err := strconv.ParseFloat(str, 64)
if err != nil {
fmt.Println("转换错误:", err)
} else {
fmt.Printf("字符串 '%s' 转为浮点型为：%f\n", str, num)
}
}
El resultado de la ejecución del ejemplo anterior es:
字符串 '3.14' 转为浮点型为：3.140000
El siguiente ejemplo convierte un número de coma flotante en una cadena:
ejemplo
package main
import (
"fmt"
"strconv"
)
func main() {
num := 3.14
str := strconv.FormatFloat(num, 'f', 2, 64)
fmt.Printf("浮点数 %f 转为字符串为：'%s'\n", num, str)
}
El resultado de la ejecución del ejemplo anterior es:
浮点数 3.140000 转为字符串为：'3.14'
Conversión de tipo de interfaz
Hay dos casos de conversión de tipo de interfaz: aserción de tipo y conversión de tipo.
La aserción de tipo se utiliza para convertir un tipo de interfaz en un tipo específico y su sintaxis es:
value.(type)
或者
value.(T)
donde valor es una variable de tipo de interfaz y tipo o T es el tipo al que convertir.
Si la afirmación de tipo es exitosa, devuelve el valor convertido y un valor booleano que indica si la conversión fue exitosa.
ejemplo
package main
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 de interfaz i y le asignamos la cadena "Hello, World". Luego, usamos una aserción de tipo para convertir i en tipo de cadena y asignamos el valor convertido a la variable str. Finalmente, usamos la variable ok para verificar si la conversión de tipo fue exitosa, y si fue exitosa, imprimimos la cadena convertida; de lo contrario, imprimimos un mensaje de que la conversión falló.
La conversión de tipo se utiliza para convertir el valor de un tipo de interfaz a otro tipo de interfaz, y su sintaxis es:
T(value)
T es el tipo de interfaz de destino y el valor es el valor a convertir.
En la conversión de tipos, debemos asegurarnos de que el valor a convertir sea compatible con el tipo de interfaz de destino, de lo contrario, el compilador informará un error.
ejemplo
package main
import "fmt"
type Writer interface {
Write([]byte) (int, error)
}
type StringWriter struct {
str string
}
func (sw *StringWriter) Write(data []byte) (int, error) {
sw.str += string(data)
return len(data), nil
}
func main() {
var w Writer = &StringWriter{
}
sw := w.(*StringWriter)
sw.str = "Hello, World"
fmt.Println(sw.str)
}
En el ejemplo anterior, definimos una interfaz Writer y una estructura StringWriter que implementa la interfaz. Luego, asignamos el puntero del tipo StringWriter a la variable w del tipo de interfaz Writer. A continuación, usamos la conversión de tipo para convertir w al tipo StringWriter y asignamos el valor convertido a la variable sw. Finalmente, usamos sw para acceder al campo str en la estructura StringWriter e imprimir su valor.