¿Qué son los structs en Go?

Question

Accepted Answer

Un **struct** es un tipo compuesto que agrupa campos relacionados — la forma que tiene Go de definir tipos de datos personalizados y modelar entidades. Como Go no tiene clases, los structs (más métodos) son cómo haces programación de estilo orientado a objetos.

## Definir y usar un struct

```go
type Person struct {
    Name string     // exported (capitalized) → accessible from other packages
    Age  int
    email string    // unexported (lowercase) → package-private
}

// creating instances
p1 := Person{Name: "Ann", Age: 30}        // named fields (preferred — clear, order-independent)
p2 := Person{"Bob", 25, "bob@x.com"}       // positional (fragile — order matters)
var p3 Person                              // zero value: {"", 0, ""}

p1.Name          // access fields with dot notation
p1.Age = 31      // mutate
```

## Visibilidad de campo mediante capitalización

```text
Capitalized field/type/func name → EXPORTED (public, usable outside the package)
lowercase name → unexported (private to the package)
```

Go usa capitalización, no palabras clave, para la visibilidad — una convención característica.

## Métodos en structs (OOP de Go)

```go
// a method is a function with a RECEIVER (the struct it operates on)
func (p Person) Greet() string {           // value receiver
    return "Hi, I'm " + p.Name
}
func (p *Person) Birthday() {                // pointer receiver — can MODIFY the struct
    p.Age++
}

p1.Greet()       // "Hi, I'm Ann"
p1.Birthday()    // modifies p1 (Go auto-takes the address)
```

Los métodos adjuntan comportamiento a structs mediante un *receiver*. Los receivers de puntero (`*Person`) permiten que los métodos modifiquen el struct; los receivers de valor obtienen una copia.

## Los Structs son tipos de valor

```go
p1 := Person{Name: "Ann"}
p2 := p1            // COPIES the entire struct (independent)
p2.Name = "Bob"
fmt.Println(p1.Name)   // "Ann" — unchanged (it was a copy)

// pass a pointer to share/modify
func update(p *Person) { p.Name = "X" }
```

Asignar o pasar un struct **lo copia** (semántica de valor) — para compartir o modificar, usa un puntero.

## Etiquetas de struct (metadatos)

```go
type User struct {
    Name  string `json:"name"`           // tags guide encoding/decoding
    Email string `json:"email,omitempty"`
}
```

Las etiquetas adjuntan metadatos (utilizados por JSON, DB, bibliotecas de validación) leídos mediante reflection.

## Por qué es importante

Los structs son la forma principal de modelar datos y construir tipos personalizados en Go — y combinados con métodos, así es cómo Go hace programación de estilo orientado a objetos (no tiene clases).

Comprenda la definición de struct, la convención **de visibilidad basada en capitalización** (única en Go), **semántica de valor** (la asignación copia — así que usa punteros para compartir/modificar, una trampa común), métodos con receivers de valor vs puntero y etiquetas de struct (para mapeo JSON/DB) es fundamental para casi todo el código Go.

Los Structs aparecen en todas partes — modelos de dominio, configuración, cargas de API, estructuras de datos — lo que los hace conocimiento esencial y cotidiano para trabajar efectivamente en Go.