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 a int = 10
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

package main

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

package main

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

package main

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

package main

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

package main

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

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 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

package main

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:

  1. Definir la interfaz y la estructura:

    • WriterLa interfaz defineWriteel método.
    • StringWriterLa estructura implementaWriteel método.
  2. Conversión de tipos:

    • va aStringWriterLa instancia se asigna aWritervariable de interfazw。
    • Utilicew.(*StringWriter)va aWriterla conversión del tipo de interfaz aStringWritertipo.
  3. Acceso a campos:

    • ModificarStringWriterel campo destr, y imprimir su valor.

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

package main

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