Structs en Go: Definición y estrategias de inicialización

Un struct es un tipo de dato compuesto que agrupa campos de distintos tipos bajo un mismo nombre, permitiéndote modelar entidades complejas en lugar de solo tipos primitivos. Cuando declaras una variable de tipo struct sin asignarle un valor inicial, Go garantiza que todos sus campos se inicialicen en su valor cero (por ejemplo, 0 para enteros, false para booleanos o nil para punteros), lo que evita el problema de la memoria con basura que suele ocurrir en lenguajes de bajo nivel.

Para instanciar un struct, puedes usar la inicialización por nombres de campos o la posicional. La primera es la forma idiomática y segura; la segunda es rápida pero extremadamente frágil. Si intentas usar la inicialización posicional con un struct definido en otro paquete, el compilador te dará un error. Esta es una decisión de diseño deliberada para proteger la compatibilidad de las APIs: si un desarrollador cambia el orden de los campos en un paquete externo, la inicialización posicional podría intercambiar valores silenciosamente sin que el compilador se dé cuenta, introduciendo errores lógicos imposibles de detectar a simple vista.

package main

import (
	"fmt"
)

// Point representa una coordenada en un plano 2D.
type Point struct {
	X float64
	Y float64
}

// Rectangle define un área usando un punto de origen y dimensiones.
type Rectangle struct {
	Origin Point
	Width  float64
	Height float64
}

func main() {
	// 1. Zero value: Un struct se inicializa con sus campos en sus valores cero.
	// No necesitas preocuparte por basura en memoria o valores aleatorios.
	var p1 Point
	fmt.Printf("Punto zero value: %+v\n", p1)

	// 2. Idiomática: Usar nombres de campos es la forma segura y recomendada.
	// Si en el futuro alguien cambia el orden de X o Y, este código sigue funcionando.
	p2 := Point{
		X: 10.5,
		Y: 20.0,
	}
	fmt.Printf("Punto idiomático: %+v\n", p2)

	// 3. Posicional: Rápida pero peligrosa.
	// Solo se recomienda en tests locales dentro del mismo package.
	p3 := Point{30, 40}
	fmt.Printf("Punto posicional: %+v\n", p3)

	// 4. Composición: Inicialización de structs anidados.
	rect := Rectangle{
		Origin: Point{X: 0, Y: 0},
		Width:  100,
		Height: 50,
	}
	fmt.Printf("Rectángulo: %+v\n", rect)
}

En el ejemplo anterior, cuando declaramos var p1 Point, el runtime de Go asigna memoria y asegura que tanto X como Y sean 0.0. Al usar p2 := Point{X: 10.5, Y: 20.0}, estamos siendo explícitos; esto es vital en estructuras grandes donde omitir un campo podría llevarte a usar inadvertidamente un valor cero cuando en realidad querías otro valor.

La variable p3 utiliza la inicialización posicional {30, 40}, lo cual es sintácticamente correcto, pero vincula la lógica de tu código al orden físico de los campos en la definición de Point. Por último, en rect, vemos cómo la estructura Rectangle utiliza a Point como un tipo compuesto, demostrando que los structs pueden anidarse para construir modelos de datos complejos y jerárquicos.

El error frecuente

La inicialización posicional puede causar errores lógicos silenciosos si un tercero cambia la estructura en un paquete que tú consumes.

// Supongamos que este código está en el paquete "geo"
type Config struct {
    Lat float64
    Lon float64
}

// En tu código principal, haces esto:
cfg := geo.Config{40.41, -3.70} // Asumes {Lat, Lon}

// Pero el autor de "geo" decide que, por orden alfabético, sea:
// type Config struct {
//     Lon float64
//     Lat float64
// }

// Tu código sigue compilando perfectamente, pero ahora has invertido 
// las coordenadas sin que el compilador te avise.

Usar nombres de campos es la única forma de garantizar que tu código sea resiliente a cambios en la arquitectura de las dependencias.

N° 58