Definición y uso de un struct

Un struct agrupa campos con nombre en un solo tipo. Es el camino hacia adelante construir "objetos", más literales e inmediatos que las clases, sin herencia ni constructores incorporados.

Declaración

type Person struct {
    Name string
    Age  int
}

type introduce un nuevo tipo con nombre. Los campos se escriben uno por uno. línea, nome tipo. Campos consecutivos del mismo tipo pueden comparta la declaración: X, Y int.

Creación

// con campi nominati (raccomandato: robusto al riordino)
p := Person{Name: "Ada", Age: 36}

// posizionale (fragile: dipende dall'ordine di dichiarazione)
q := Person{"Ada", 36}

// zero value: tutti i campi al loro zero value
var r Person          // r = {Name: "", Age: 0}

// puntatore: alloca con & o new
ptr := &Person{Name: "Ada"}
ptr2 := new(Person)   // *Person verso struct zero-value

Acceso a campos

p := Person{Name: "Ada", Age: 36}
fmt.Println(p.Name, p.Age)

p.Age = 37            // mutazione (se p è una variabile)

En un puntero, ptr.Name funciona directamente: Go hace lo desreferencia implícita. No -> como en C.

Visibilidad: el caso de las mayúsculas

Los campos con mayúsculas se exportan (visibles para otros). paquete); minúscula = privado al paquete actual.

type User struct {
    Name   string  // esportato
    salt   []byte  // privato al package
}

Esta misma regla se aplica a todos los identificadores en Go: tipos, funciones, variables, campos.

Estructuras anónimas y anidadas

// anonima (utile per dati ad-hoc)
config := struct {
    Host string
    Port int
}{Host: "localhost", Port: 8080}

// nidificata
type Address struct {
    Street string
    City   string
}
type Customer struct {
    Name    string
    Address Address
}

Comparabilidad

Dos estructuras son comparables con == si TODOS sus campos son comparables (sin corte/mapa/función dentro de ellos):

a := Person{Name: "Ada", Age: 36}
b := Person{Name: "Ada", Age: 36}
fmt.Println(a == b)   // true

Esto también le permite utilizarlas como claves de mapa.

Pruébalo tú mismo

// in package altro
type X struct {
    name string
}

Resumen

• type Nome struct { ... }: Nuevo tipo con nombre con campos con nombre.
• Construcción: T{Campo: valore, ...} (recomendado) o posicional.
• Valor cero: todos los campos en cero de su tipo.
• &T{...} y new(T) para puntero; desreferencia implícita (p.Campo a *T).
• Mayúsculas = exportado; minúscula = privado al paquete.
• Estructuras comparables con == si todos los campos lo son; Utilizable como claves de mapa.