Skip to content

Cheatsheet de Go (Golang)

Última verificación mayo 2026 — corre en tu navegador
Cheatsheet de Go
var x int = 10

Variable con tipo explícito

Básicos
x := 10

Declaración corta de variable (inferida)

Básicos
const Pi = 3.14159

Declaración de constante

Básicos
int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64

Tipos enteros

Básicos
float32 float64

Tipos de punto flotante

Básicos
string bool byte rune

Otros tipos básicos

Básicos
if x > 0 { ... } else if x == 0 { ... } else { ... }

If/else (sin paréntesis necesarios)

Básicos
for i := 0; i < 10; i++ { ... }

Bucle for clásico

Básicos
for _, v := range slice { ... }

Rango sobre slice/map/string

Básicos
for condition { ... }

Bucle estilo while

Básicos
for { ... }

Bucle infinito

Básicos
switch x { case 1: ... case 2, 3: ... default: ... }

Switch (sin fallthrough por defecto)

Básicos
fmt.Println("hello")

Imprimir con salto de línea

Básicos
fmt.Sprintf("name: %s, age: %d", name, age)

Cadena con formato

Básicos
strconv.Atoi(s) / strconv.Itoa(n)

Conversión string <-> int

Básicos
s := []int{1, 2, 3}

Crear un slice literal

Slices y Maps
s := make([]int, 0, 10)

Crear slice con longitud y capacidad

Slices y Maps
s = append(s, 4, 5)

Añadir elementos al slice

Slices y Maps
s[1:3]

Porción de slice (índice 1 a 2)

Slices y Maps
len(s) / cap(s)

Longitud y capacidad del slice

Slices y Maps
copy(dst, src)

Copiar elementos entre slices

Slices y Maps
s = append(s[:i], s[i+1:]...)

Eliminar elemento en índice i

Slices y Maps
sort.Ints(s) / sort.Strings(s)

Ordenar slice in situ

Slices y Maps
slices.Contains(s, val)

Comprobar si el slice contiene un valor (Go 1.21+)

Slices y Maps
m := map[string]int{"a": 1}

Crear un map literal

Slices y Maps
m := make(map[string]int)

Crear map vacío

Slices y Maps
m["key"] = value

Establecer valor del map

Slices y Maps
val, ok := m["key"]

Obtener valor con comprobación de existencia

Slices y Maps
delete(m, "key")

Eliminar clave del map

Slices y Maps
for k, v := range m { ... }

Iterar sobre entradas del map

Slices y Maps
func add(a, b int) int { return a + b }

Función con tipo de retorno

Funciones
func divide(a, b float64) (float64, error)

Múltiples valores de retorno

Funciones
func greet(name string, opts ...string)

Función variádica

Funciones
result, err := divide(10, 3)

Capturar múltiples retornos

Funciones
fn := func(x int) int { return x * 2 }

Función anónima / cierre

Funciones
defer file.Close()

Diferir ejecución hasta que la función retorne

Funciones
func init() { ... }

Función de inicialización del paquete

Funciones
type User struct { Name string Age int }

Definición de tipo struct

Structs
u := User{Name: "Alice", Age: 30}

Struct literal

Structs
u := &User{Name: "Alice"}

Puntero a struct

Structs
func (u User) Greet() string { return "Hi " + u.Name }

Método en struct (receptor por valor)

Structs
func (u *User) SetName(n string) { u.Name = n }

Método con receptor puntero (mutar)

Structs
type Admin struct { User Role string }

Incrustación de struct (composición)

Structs
type Config struct { Host string `json:"host"` }

Etiquetas de struct (JSON, DB, etc.)

Structs
type Reader interface { Read(p []byte) (n int, err error) }

Definición de interfaz

Interfaces
type Stringer interface { String() string }

Interfaz Stringer (como toString)

Interfaces
interface{} / any

Interfaz vacía (acepta cualquier tipo)

Interfaces
val, ok := i.(ConcreteType)

Aserción de tipo con comprobación

Interfaces
switch v := i.(type) { case string: ... case int: ... }

Switch de tipo

Interfaces
go func() { ... }()

Lanzar goroutine

Concurrencia
ch := make(chan int)

Crear canal sin búfer

Concurrencia
ch := make(chan int, 10)

Crear canal con búfer (capacidad 10)

Concurrencia
ch <- value

Enviar valor al canal

Concurrencia
value := <-ch

Recibir valor del canal

Concurrencia
close(ch)

Cerrar canal (no más envíos)

Concurrencia
select { case v := <-ch1: ... case ch2 <- val: ... default: ... }

Select en múltiples canales

Concurrencia
var mu sync.Mutex mu.Lock() defer mu.Unlock()

Mutex para estado compartido

Concurrencia
var wg sync.WaitGroup wg.Add(1) go func() { defer wg.Done() ... }() wg.Wait()

WaitGroup para coordinar goroutines

Concurrencia
if err != nil { return fmt.Errorf("failed: %w", err) }

Envolver y propagar error

Manejo de errores
errors.New("something failed")

Crear error simple

Manejo de errores
fmt.Errorf("user %d: %w", id, err)

Crear error con formato (envolviendo)

Manejo de errores
errors.Is(err, target)

Comprobar si el error coincide con el objetivo

Manejo de errores
errors.As(err, &target)

Extraer error tipado de la cadena

Manejo de errores
type MyError struct { Code int Msg string } func (e *MyError) Error() string { return e.Msg }

Tipo de error personalizado

Manejo de errores
panic("fatal") / recover()

Panic y recover (raro, evitar)

Manejo de errores
Mostrando 65 de 65 fragmentos

Cheat Sheet de Go (Golang) — Goroutines, Channels, Interfaces y Manejo de Errores

Go apareció en 2009 con la intención de mantenerse pequeño: lista corta de palabras clave, estilo impuesto por gofmt y concurrencia con goroutines y canales. La chuleta de abajo cubre 60+ fragmentos en básicos, slices y maps, funciones, structs, interfaces, concurrencia y manejo de errores. La mayoría de los líos en código Go no vienen de olvidar sintaxis. Vienen de rarezas que parecen normales hasta que muerden. Un valor de interfaz que guarda un puntero tipado nil no es nil en sí mismo, así que `if err != nil` da true sobre un `err` al que se asignó `var p *MyError; return p` — la interfaz sigue cargando el tipo. Una slice y su `append` pueden compartir o no el array subyacente según la capacidad, así que hacer append sobre una slice recibida puede mutar los datos del llamante o dejar de reflejarlos en silencio. El orden de iteración de los maps se randomiza adrede entre ejecuciones, así que un test dependiente del orden pasa nueve veces y falla a la décima. Estos son los fragmentos consultados al depurar eso: el chequeo de nil, el patrón de append, la dirección del canal.

Relacionados: Cheatsheet de Rust Cheatsheet de Python Cheatsheet de Linux Cheatsheet de Git CMD vs PowerShell Cheatsheet de JavaScript
Trampas habituales en Go

Hay un puñado de patrones que merecen sitio cerca de la cabecera de cualquier archivo Go. Conviene devolver `nil` literal cuando no hay error en vez de un nil tipado envuelto en una interfaz, porque `return (*MyError)(nil)` contra un tipo de retorno `error` produce una interfaz no-nil que se salta los chequeos `if err != nil` aguas abajo. Conviene envolver los errores propagados con `fmt.Errorf("contexto: %w", err)` para que los llamantes puedan usar después `errors.Is` y `errors.As` — un `%v` a secas pierde esa información. `defer` evalúa sus argumentos en el punto donde se ejecuta la sentencia, no cuando la llamada diferida se dispara, así que `defer log.Print(time.Now())` registra el instante de inicio y no el de fin. El bucle `for _, v := range slice` reutiliza la misma variable `v` entre iteraciones, inofensivo hasta que una goroutine la captura por referencia (Go 1.22 hizo que cada iteración tenga su propio ámbito, pero el código pre-1.22 todavía en producción necesita el sombreado explícito `v := v`). La chuleta agrupa todo esto en Básicos, Slices y Maps, Funciones, Structs, Interfaces, Concurrencia y Manejo de Errores para que la sección adecuada esté a un clic.

  • Más de 60 fragmentos prácticos de Go
  • 7 categorías desde básicos hasta concurrencia
  • Goroutines y canales explicados
  • Patrones de manejo de errores
  • Copia al portapapeles con un clic
  • Métodos de struct e interfaces cubiertos

Gratis. Sin registro. Tus datos permanecen en tu navegador. Anuncios mediante Google AdSense (con consentimiento).

Por ·