Tipos y Estructuras

Tipos compuestos y definiciones de estructuras. Los resultados aparecen en la misma sección de código: comentarios // en la misma línea cuando son cortos, bloques // multilínea debajo de la muestra cuando no lo son.

Literal de Struct

Se prefieren los campos con nombre.

type User struct{ ID int; Name string }
u := User{ID: 1, Name: "Ada"}
u.ID  // 1

Añadir a Slice

Crece slices con append.

s := []int{1, 2}
s = append(s, 3)
s  // [1 2 3]

Búsqueda en Map

El modismo "comma-ok" para presencia.

m := map[string]int{"a": 1}
v, ok := m["a"]
v  // 1
// ok == true

Array Fijo

Los arrays tienen una longitud fija en el tipo.

var a [3]int
a[0] = 7
a[0]  // 7
// len(a) == 3

Alias de tipo

Alias frente a tipo definido.

type ID = int  // alias
type UserID int // distinto
UserID(3)  // 3

Slicing de Slice

El slicing comparte el array subyacente.

s := []int{0, 1, 2, 3}
s[1:3]  // [1 2]

make para Map

Pre-dimensiona los mapas cuando se conocen.

m := make(map[string]int, 8)
m["x"] = 1
len(m)  // 1

delete de Map

Elimina una clave.

m := map[string]int{"a": 1}
delete(m, "a")
len(m)  // 0

Campo Incrustado

Promoción de campos/métodos incrustados.

type Point struct{ X, Y int }
type Dot struct{ Point }
d := Dot{Point: Point{1, 2}}
d.X  // 1

Etiquetas de Struct

Etiquetas para encoding/json etc.

type T struct {
    Name string `json:"name"`
}
// reflect.TypeOf(T{}).Field(0).Tag.Get("json") == "name"

copy de Slice

copy devuelve el número de elementos copiados.

dst := make([]int, 2)
n := copy(dst, []int{1, 2, 3})
n  // 2
// dst == [1 2]

Slice nil vs Vacío

nil y vacío tienen len 0; nil es nil.

var s []int
s == nil  // true
len(s)    // 0

Claves Comparables

Las claves de Map deben ser comparables.

m := map[[2]int]string{{1, 2}: "a"}
m[[2]int{1, 2}]  // "a"

Slice de Bytes y String

Convertir entre string y []byte.

b := []byte("hi")
string(b)  // "hi"

Acceso a Campo con Puntero

Go desreferencia automáticamente los punteros a structs.

u := &User{ID: 9}
u.ID  // 9

Relacionado

• Sintaxis y Fundamentos - declaraciones
• Funciones y Métodos - métodos sobre tipos
• Interfaces y Genéricos - satisfacción de interfaces

Enlaces Externos Relacionados

• Especificación del Lenguaje Go - La referencia formal del lenguaje.
• Effective Go - Guía oficial para escribir Go claro e idiomático.
• Go by Example - Ejemplos de código prácticos anotados.
• The Go Programming Language (ebook) - Donovan & Kernighan.
• Learning Go (2nd Edition) - Jon Bodner.

Versiones de la pila: Go 1.26.x · chi/gin/echo latest (verificar en la compilación)