En Go, existe una diferencia crítica entre crear un “apodo” para un tipo existente y crear un tipo completamente nuevo con la misma estructura. Un tipo nombrado [disponible desde Go 1.0] es una declaración que le dice al compilador: “Aunque usemos los mismos datos de un float64, a partir de ahora esto se llama Celsius y es algo distinto”. En cambio, un alias de tipo [disponible desde Go 1.9] es simplemente un sobrenombre; para el compilador, el alias y el tipo original son la misma entidad.
Esto sucede así porque Go prioriza la seguridad de tipos y la claridad del modelo de dominio. Si permitiera que cualquier número fuera tratado como una temperatura sin una conversión explícita, podrías sumar accidentalmente grados Celsius con Fahrenheit, y el compilador no te avisaría. Usamos tipos nombrados cuando queremos modelar conceptos específicos del negocio (como UserID o Kilometros) o cuando necesitamos anexar métodos (funciones propias) a un tipo que ya existe, algo que es imposible en los tipos básicos de Go como string o float64. Por el contrario, usamos alias principalmente durante procesos de refactorización masivos para renombrar un tipo sin romper el código de otros paquetes. Si confundes un alias con un tipo nombrado, perderás la protección del compilador contra errores lógicos y no podrás dotar al tipo de comportamientos personalizados mediante métodos.
package main
import (
"fmt"
)
// Celsius es un TIPO NOMBRADO.
// Aunque su base es un float64, para Go es un tipo con su propia identidad.
type Celsius float64
// Kelvin es un ALIAS de float64.
// El signo '=' indica que Kelvin y float64 son exactamente lo mismo.
type Kelvin = float64
// Podemos definir métodos en tipos nombrados como Celsius.
// Esto permite que el tipo "sepa" cómo comportarse.
func (c Celsius) A Fahrenheit() float64 {
return float64(c)*9/5 + 32
}
func main() {
// 1. Comportamiento de Tipo Nombrado
c := Celsius(25.5) // Iniciamos con valor de Celsius
f := 10.5 // Un float64 estándar
// No podemos sumar Celsius y float64 directamente.
// El compilador exige una conversión explícita para asegurar que el programador sabe qué hace.
// sum := c + f // Esto daría un error de compilación.
sum := c + Celsius(f)
fmt.Printf("Temperatura: %.2f°C, suma con float64: %.2f°C\n", c, sum)
fmt.Printf("Conversión a Fahrenheit: %.2f°F\n", c.AFahrenheit())
// 2. Comportamiento de Alias
k := Kelvin(300.0) // Aunque lo llamemos Kelvin, es un float64
// Como es un alias, la compatibilidad es total y automática.
// No hay necesidad de conversiones.
fmt.Printf("Kelvin (alias): %.2f, Float64: %.2f\n", k, f)
fmt.Printf("Suma de alias y nativo: %.2f\n", k+f)
}
Análisis del código
Fíjate en la definición de Celsius. Al no usar el signo =, hemos creado una nueva identidad. Por eso, cuando intentamos operar con c y f en la línea sum := c + Celsius(f), nos vemos obligados a convertir f a Celsius explícitamente. El compilador actúa como un guardián, impidiendo mezclas accidentales. Además, gracias a que Celsius es un tipo propio, podemos declararle el método AFahrenheit.
En el caso de Kelvin, el uso del = lo convierte en un alias. Esto significa que Kelvin y float64 son intercambiables en cualquier contexto. En la línea k + f, el compilador ni siquiera nota la diferencia; simplemente ve dos números de punto flotante operando. Esta es la razón por la cual no puedes definir métodos en un alias que apunte a un tipo nativo (como float64), porque estarías intentando añadirle comportamiento a algo que pertenece al lenguaje mismo, no a tu programa.
El uso de tipos nombrados permite que tu código sea autodocumentado: al leer una función que recibe Celsius, entiendes la unidad de medida sin mirar comentarios, algo que un simple float64 no te garantiza.
El error frecuente
Un error muy común ocurre cuando un desarrollador usa un alias cuando lo que realmente necesita es un tipo nombrado para evitar errores de lógica.
// Error: Usar un alias cuando se requiere seguridad semántica
type Metros = float64
type Pies = float64
func CalcularDistancia(m Metros, p Pies) float64 {
// El compilador permitirá esto sin protestar,
// pero la lógica es errónea si mezclas unidades sin convertir.
return m + p
}
Si usas el alias =, el compilador tratará a Metros y Pies como el mismo tipo, permitiendo sumar pies a metros sin que el programa falle en la compilación, lo que resultará en un error matemático difícil de rastrear en producción.
N° 23