PricingLoginStart free
Go Academy · Lección

Conversiones de tipos en Go

Conversiones explícitas, alias de tipos y tipos definidos

Lección 4 de 412 pasos

Conversiones de tipos en Go es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.

¿Por qué usar conversiones explícitas?

Go nunca convierte implícitamente entre tipos. Esto evita errores sutiles en los que un entero pequeño se desborda silenciosamente al convertirse en uno más grande o un float pierde precisión.

  • Las conversiones deben escribirse explícitamente: T(value)
  • El compilador detecta los tipos incompatibles en tiempo de compilación
  • Esto hace que el código Go sea predecible y seguro

Conversiones numéricas

Convierta entre tipos numéricos usando el tipo de destino como una llamada a función:

package main

func main() {
    var i int = 42
    var f float64 = float64(i)
    var u uint = uint(f)
    _ = u
}

Riesgo de truncamiento

Convertir de un tipo más grande a uno más pequeño trunca el valor. No se genera ningún error; debe tener cuidado:

package main

func main() {
    big := int64(300)
    small := int8(big) // 300 % 256 = 44 — silent truncation!
    _ = small
}

Conversiones entre string y []byte

Convertir entre string y []byte copia los datos:

package main

func main() {
    s := "hello"
    b := []byte(s)   // string to byte slice
    b[0] = 'H'
    s2 := string(b)  // byte slice to string
    _ = s2
}

string y []rune

Para manipular caracteres de forma segura con Unicode, convierta a []rune:

package main

func main() {
    s := "Merhaba"
    runes := []rune(s)
    _ = len(runes) // character count, not byte count
}

Paquete strconv

Para convertir entre cadenas y números, use el paquete strconv:

import "strconv"

func main() {
    n, err := strconv.Atoi("42")   // string -> int
    s := strconv.Itoa(123)          // int -> string
    _ = n; _ = err; _ = s
}

strconv.ParseFloat y FormatFloat

Analice y dé formato a cadenas de coma flotante de forma segura:

import "strconv"

func main() {
    f, err := strconv.ParseFloat("3.14", 64)
    if err != nil { return }
    s := strconv.FormatFloat(f, 'f', 2, 64) // "3.14"
    _ = s
}

Alias de tipos frente a tipos definidos

Go distingue entre alias de tipos y tipos definidos:

  • type Celsius float64: tipo definido nuevo; requiere una conversión explícita hacia y desde float64
  • type Celsius = float64: alias; es intercambiable con float64

Ejemplo de tipo definido

Los tipos definidos mejoran la claridad de la API y evitan mezclar valores accidentalmente:

type Celsius float64
type Fahrenheit float64

func CtoF(c Celsius) Fahrenheit {
    return Fahrenheit(c*9/5 + 32)
}

func main() {
    boiling := Celsius(100)
    _ = CtoF(boiling)
}

Conversiones de interfaces

Cualquier valor puede convertirse al tipo de interfaz que satisface. Para volver a convertirlo se necesita una aserción de tipo:

var i interface{} = "hello"
s, ok := i.(string) // type assertion
if ok {
    _ = s // safe to use
}

Comprobación rápida

¿Qué función convierte una cadena en un entero en Go?

Responde en la lección interactiva

Resumen: conversiones de tipos

Conclusiones clave sobre las conversiones de tipos en Go:

  • Go nunca convierte tipos implícitamente; use la sintaxis T(value)
  • Las conversiones numéricas pueden truncar valores; sea explícito sobre este riesgo
  • []byte(s) y string(b) copian los datos
  • Use strconv.Atoi / strconv.Itoa para convertir entre cadenas y números
  • Los tipos definidos requieren conversiones explícitas; los alias no

Siguiente curso: control de flujo con if, for y switch.

Gratis para empezar

Aprende Go con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos
51
Lecciones
203
Empezar a aprender gratisVer el curso completo

Preguntas frecuentes

¿La lección «Conversiones de tipos en Go» es gratis?

Sí — el texto completo de «Conversiones de tipos en Go» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Conversiones de tipos en Go»?

Conversiones explícitas, alias de tipos y tipos definidos Practicas Go Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Go Academy?

No se requiere experiencia previa. Go Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Conversiones de tipos en Go»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Go Academy?

Sí. Cada lección de Go Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Declaración de variables en Go
  2. Tipos integrados de Go
  3. Constantes e iota
  4. Conversiones de tipos en Go
← Volver a Go Academy