Docs ejecutables de Go: Structs

Q: ¿Cómo se comparan dos structs en Go?

Con ==, si todos los campos son comparables. Dos valores struct son iguales cuando todos sus campos correspondientes lo son. Un struct que contiene un campo slice, map o función no se puede comparar con == (error de compilación); compara tú los campos o usa reflect.DeepEqual en los tests.

Q: ¿Qué son los struct tags en Go?

Literales de string detrás del tipo de un campo, como json:"name,omitempty" . El compilador los ignora; paquetes como encoding/json, los drivers de bases de datos y los validadores los leen con reflexión para controlar cómo se codifican, nombran o comprueban los campos.

Q: ¿Cómo imprimo un struct con los nombres de sus campos en Go?

Usa fmt.Printf("%+v\n", s), que imprime {Name:Ana Age:31}. %v imprime solo los valores, y %#v imprime sintaxis de Go incluido el nombre del tipo: main.User{Name:"Ana", Age:31}.

Definir y crear un struct

Un tipo struct es una lista de campos con nombre. Se declara con type Name struct { ... } y los valores se crean con un literal compuesto.

package main

import "fmt"

type User struct {
	Name  string
	Email string
	Age   int
	Admin bool
}

func main() {
	a := User{Name: "Ana", Email: "ana@example.com", Age: 31}
	fmt.Println(a.Name, a.Age)

	a.Age++ // fields are accessed and set with a dot
	fmt.Printf("%+v\n", a)

	var b User // zero value: every field at its own zero
	fmt.Printf("%+v\n", b)
	fmt.Printf("%#v\n", User{Name: "Bob"})
}

Salida:

Ana 31
{Name:Ana Email:ana@example.com Age:32 Admin:false}
{Name: Email: Age:0 Admin:false}
main.User{Name:"Bob", Email:"", Age:0, Admin:false}

%+v imprime los nombres de los campos y %#v imprime sintaxis de Go. Los dos son la forma más rápida de inspeccionar un struct al depurar.

Los campos del mismo tipo pueden compartir línea: X, Y float64. Los nombres de campo con mayúscula inicial son exportados (visibles para otros paquetes y para encoding/json); los que van en minúscula, no.

Formas del literal

User{Name: "Ana", Age: 31}        // named fields: order-free, omitted fields are zero
User{"Ana", "a@x.com", 31, false} // positional: every field, in order
&User{Name: "Ana"}                // pointer to a new struct
new(User)                         // pointer to a zeroed struct

Prefiere los campos con nombre. Los literales posicionales se rompen cuando alguien añade o reordena un campo, y go vet avisa de ellos en tipos struct de otros paquetes (por ejemplo net/url.Error struct literal uses unkeyed fields). La forma posicional está bien para tipos locales diminutos como Point{1, 2}.

Sin valores por defecto: valores cero y constructores

Go no tiene valores por defecto en los campos ni constructores en el lenguaje. Todos los campos empiezan con el valor cero de su tipo: 0, "", false, nil. Dos idiomas cubren el hueco.

Haz que el valor cero sea útil. sync.Mutex, bytes.Buffer y strings.Builder funcionan sin inicialización. Cuando puedas diseñar un tipo así, hazlo.

Escribe una función NewX cuando un campo necesite un valor por defecto distinto de cero o haya que reservar algo, como un map:

package main

import (
	"fmt"
	"time"
)

type Server struct {
	Addr    string
	Timeout time.Duration
	routes  map[string]string
}

func NewServer(addr string) *Server {
	return &Server{
		Addr:    addr,
		Timeout: 30 * time.Second,
		routes:  make(map[string]string),
	}
}

func (s *Server) Handle(path, name string) {
	s.routes[path] = name
}

func main() {
	s := NewServer(":8080")
	s.Handle("/", "index")
	fmt.Println(s.Addr, s.Timeout, len(s.routes))
}

NewServer devuelve un puntero porque el servidor tiene métodos que lo modifican y va a compartirse. Devolver el struct por valor también es común en tipos pequeños e inmutables (time.Date devuelve un time.Time).

Punteros a structs

Go desreferencia automáticamente los punteros a structs al acceder a los campos. Con p := &User{}, escribes p.Name, no (*p).Name.

package main

import "fmt"

type Point struct{ X, Y int }

func moveBy(p *Point, dx, dy int) {
	p.X += dx
	p.Y += dy
}

func main() {
	pt := Point{1, 2}
	moveBy(&pt, 10, 10)
	fmt.Println(pt)

	copyPt := pt // a struct assignment copies every field
	copyPt.X = 0
	fmt.Println(pt, copyPt)

	alias := &pt // a pointer shares the same struct
	alias.Y = 0
	fmt.Println(pt)
}

Salida:

{11 12}
{11 12} {0 12}
{11 0}

Los structs son valores. La asignación y los argumentos de función los copian; un puntero comparte uno solo. Las copias campo a campo son superficiales: un campo slice o map de la copia sigue apuntando a los mismos datos. Consulta punteros para saber cuándo usar cada cosa.

Structs anónimos

Un tipo struct se puede escribir en línea sin nombre. Es útil para agrupaciones puntuales, tests basados en tablas y para decodificar JSON que solo lees una vez.

package main

import "fmt"

func main() {
	point := struct {
		X, Y int
	}{3, 4}
	fmt.Println(point.X, point.Y)

	tests := []struct {
		in   string
		want int
	}{
		{"go", 2},
		{"gopher", 6},
	}
	for _, tc := range tests {
		fmt.Println(tc.in, len(tc.in) == tc.want)
	}
}

La tabla []struct{ in string; want int } es la forma estándar de un test en Go.

Comparar structs

Los structs se pueden comparar con == cuando todos sus campos son comparables. La igualdad significa que todos los campos son iguales. Los structs comparables también pueden ser claves de un map.

package main

import (
	"fmt"
	"slices"
)

type Point struct{ X, Y int }

type Polygon struct {
	Name   string
	Points []Point // slices make the struct incomparable
}

func main() {
	fmt.Println(Point{1, 2} == Point{1, 2})

	grid := map[Point]string{{0, 0}: "origin"}
	fmt.Println(grid[Point{0, 0}])

	a := Polygon{"tri", []Point{{0, 0}, {1, 0}, {0, 1}}}
	b := Polygon{"tri", []Point{{0, 0}, {1, 0}, {0, 1}}}
	// fmt.Println(a == b) // compile error: struct containing []Point cannot be compared
	fmt.Println(a.Name == b.Name && slices.Equal(a.Points, b.Points))
}

Para un struct con campos slice o map, escribe un método Equal o compara en los tests con reflect.DeepEqual.

Struct tags

Un tag es un literal de string detrás del tipo de un campo. El lenguaje lo ignora; las librerías lo leen con reflexión. Quien más lo lee es encoding/json:

package main

import (
	"encoding/json"
	"fmt"
)

type Product struct {
	ID       int     `json:"id"`
	Name     string  `json:"name"`
	Price    float64 `json:"price,omitempty"`
	internal string  // unexported: never encoded
}

func main() {
	out, err := json.Marshal(Product{ID: 7, Name: "Mug", internal: "x"})
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(string(out))
}

Esto imprime {"id":7,"name":"Mug"}: el tag renombra los campos, omitempty quita el Price a cero y el campo no exportado es invisible para el encoder. Los tags siguen la convención key:"value", con varias claves separadas por espacios: `json:"name" db:"user_name"`. Un tag mal formado compila sin problemas y se ignora en silencio, algo que go vet detecta. La página de json cubre las opciones.

Structs vacíos y orden de los campos

struct{} no tiene campos y ocupa cero bytes. Se usa como valor de un set (map[string]struct{}) y como señal en los channels (chan struct{}), donde solo importa el evento.

El orden de los campos afecta a la disposición en memoria: el compilador rellena los campos hasta su alineación. Un struct de bool, int64, bool ocupa 24 bytes en sistemas de 64 bits, mientras que int64, bool, bool ocupa 16. Solo importa en tipos que se guardan en grandes cantidades.

Errores comunes

Modificar una copia. for _, u := range users { u.Age++ } cambia una copia cada vez. Usa el índice: users[i].Age++.
Olvidar inicializar un campo map. El valor cero del struct contiene un map nil; escribir en él provoca un panic. Resérvalo en un constructor.
Copiar un struct que contiene un sync.Mutex. La copia tiene su propio estado del lock. Pasa esos structs por puntero; go vet informa de la copia.
Literales posicionales para tipos de otros paquetes. Se rompen cuando se añade un campo.

Preguntas frecuentes

¿Cómo se inicializa un struct en Go?

Con un literal compuesto. Lo habitual es nombrar los campos: u := User{Name: "Ana", Age: 31}, y cualquier campo que omitas recibe su valor cero. User{} da todos los valores cero, &User{...} da un puntero, y new(User) da un puntero a un struct a cero.

¿Admite Go valores por defecto en los campos de un struct?

No. Todos los campos empiezan con el valor cero de su tipo. Lo idiomático es una función constructora, func NewServer() *Server { return &Server{Port: 8080} }, o diseñar el tipo para que su valor cero ya sea útil, como sync.Mutex y bytes.Buffer.

¿Cómo se comparan dos structs en Go?

Con ==, si todos los campos son comparables. Dos valores struct son iguales cuando todos sus campos correspondientes lo son. Un struct que contiene un campo slice, map o función no se puede comparar con == (error de compilación); compara tú los campos o usa reflect.DeepEqual en los tests.

¿Qué son los struct tags en Go?

Literales de string detrás del tipo de un campo, como `json:"name,omitempty"`. El compilador los ignora; paquetes como encoding/json, los drivers de bases de datos y los validadores los leen con reflexión para controlar cómo se codifican, nombran o comprueban los campos.

¿Cómo imprimo un struct con los nombres de sus campos en Go?

Usa fmt.Printf("%+v\n", s), que imprime {Name:Ana Age:31}. %v imprime solo los valores, y %#v imprime sintaxis de Go incluido el nombre del tipo: main.User{Name:"Ana", Age:31}.

Conceptos relacionados