Hoja de Trucos de Go
Última actualización
Hola Mundo y estructura del programa
Cada programa Go vive en un paquete; el punto de entrada es func main en el paquete main.
| Operación | Sintaxis |
|---|---|
| Declaración de paquete | package main |
| Importar un paquete | import "fmt" |
| Importar varios paquetes | import (\n "fmt"\n "os"\n) |
| Punto de entrada | func main() { ... } |
| Imprimir una línea | fmt.Println("Hello, World!") |
| Impresión con formato | fmt.Printf("%d items\n", n) |
| Ejecutar un archivo | go run main.go |
| Compilar un binario | go build |
Variables y tipos
Go es de tipado estático pero puede inferir tipos con :=.
| Operación | Sintaxis |
|---|---|
| Declarar con tipo | var age int = 30 |
| Declarar con inferencia | var name = "Ada" |
| Declaración corta | count := 0 |
| Varias a la vez | x, y := 1, 2 |
| Constante | const Pi = 3.14 |
| Valores cero | 0, "", false, nil |
| Tipos básicos | int, float64, string, bool, byte, rune |
| Conversión de tipo | f := float64(i) |
Control de flujo
Go tiene una sola palabra clave de bucle (for) y sin paréntesis alrededor de las condiciones.
| Operación | Sintaxis |
|---|---|
| If / else | if x > 0 { ... } else { ... } |
| If con sentencia de inicialización | if v, ok := m[k]; ok { ... } |
| Bucle for (estilo C) | for i := 0; i < 10; i++ { ... } |
| Bucle estilo while | for x < 100 { ... } |
| Bucle infinito | for { ... } |
| Range sobre un slice | for i, v := range items { ... } |
| Switch | switch day { case 1: ...; default: ... } |
| Switch sin expresión | switch { case x > 0: ... } |
| Break / continue | break, continue |
Funciones
Las funciones son valores de primera clase y pueden devolver varios resultados.
| Operación | Sintaxis |
|---|---|
| Función básica | func add(a int, b int) int { return a + b } |
| Tipo de parámetro compartido | func add(a, b int) int { ... } |
| Varios valores de retorno | func divmod(a, b int) (int, int) { return a / b, a % b } |
| Valores de retorno con nombre | func split(sum int) (x, y int) { x = sum / 2; return } |
| Función variádica | func sum(nums ...int) int { ... } |
| Función anónima | f := func() { ... } |
| Clausura | func counter() func() int { ... } |
| Defer (se ejecuta al retornar) | defer file.Close() |
Slices y arrays
Los arrays tienen un tamaño fijo; los slices son vistas dinámicas sobre arrays.
| Operación | Sintaxis |
|---|---|
| Array de tamaño fijo | var a [3]int |
| Literal de slice | nums := []int{1, 2, 3} |
| Crear un slice | s := make([]int, 0, 10) |
| Añadir | s = append(s, 4) |
| Longitud / capacidad | len(s), cap(s) |
| Cortar un slice | s[1:3] |
| Copiar | copy(dst, src) |
| Iterar | for i, v := range s { ... } |
Mapas
Los mapas son las tablas hash integradas de Go.
| Operación | Sintaxis |
|---|---|
| Crear un mapa | m := make(map[string]int) |
| Literal de mapa | m := map[string]int{"a": 1, "b": 2} |
| Establecer un valor | m["c"] = 3 |
| Obtener un valor | v := m["a"] |
| Comprobar existencia | v, ok := m["x"] |
| Eliminar una clave | delete(m, "a") |
| Longitud | len(m) |
| Iterar | for k, v := range m { ... } |
Structs y métodos
Los structs agrupan campos; los métodos asocian comportamiento mediante un receptor.
| Operación | Sintaxis |
|---|---|
| Definir un struct | type Point struct { X, Y int } |
| Crear una instancia | p := Point{X: 1, Y: 2} |
| Acceder a un campo | p.X |
| Puntero a un struct | p := &Point{1, 2} |
| Método con receptor por valor | func (p Point) Dist() float64 { ... } |
| Método con receptor por puntero | func (p *Point) Move(dx int) { p.X += dx } |
| Struct embebido | type Circle struct { Point; R int } |
| Etiquetas de struct | Name string con una etiqueta json:"name" entre comillas invertidas |
Interfaces
Las interfaces se satisfacen de forma implícita: cualquier tipo con los métodos correctos califica.
| Operación | Sintaxis |
|---|---|
| Definir una interfaz | type Shape interface { Area() float64 } |
| Implementar (implícito) | func (c Circle) Area() float64 { ... } |
| Interfaz vacía (any) | var x interface{} o var x any |
| Aserción de tipo | s, ok := x.(string) |
| Switch de tipo | switch v := x.(type) { case int: ... } |
| Interfaz Stringer | func (p Point) String() string { ... } |
Goroutines y canales
Las goroutines son hilos ligeros; los canales pasan valores entre ellas.
| Operación | Sintaxis |
|---|---|
| Iniciar una goroutine | go doWork() |
| Crear un canal | ch := make(chan int) |
| Canal con búfer | ch := make(chan int, 5) |
| Enviar a un canal | ch <- 42 |
| Recibir de un canal | v := <-ch |
| Cerrar un canal | close(ch) |
| Range sobre un canal | for v := range ch { ... } |
| Select sobre canales | select { case v := <-ch: ...; default: ... } |
| Grupo de espera | var wg sync.WaitGroup; wg.Add(1); wg.Wait() |
| Mutex | var mu sync.Mutex; mu.Lock(); mu.Unlock() |
Manejo de errores
Go devuelve los errores como valores: no hay excepciones.
| Operación | Sintaxis |
|---|---|
| Devolver un error | func read() (string, error) { return "", err } |
| Comprobar un error | if err != nil { return err } |
| Crear un error | errors.New("not found") |
| Error con formato | fmt.Errorf("bad id %d", id) |
| Envolver un error | fmt.Errorf("load: %w", err) |
| Desenvolver / coincidir | errors.Is(err, os.ErrNotExist) |
| Coincidir por tipo | errors.As(err, &target) |
| Panic / recover | defer func() { recover() }() |
La sintaxis de Go que más usas, en una sola página. Esta hoja de trucos de Go es una referencia rápida para el núcleo del lenguaje: variables y tipos, slices y mapas, structs e interfaces, además de las goroutines y los canales que hacen que Golang destaque en la concurrencia.
Todo lo que hay aquí es Go estándar y se compila con la cadena de herramientas oficial. Copia lo que necesites o prueba cada fragmento en vivo en el playground de Go, sin necesidad de instalar nada.
Preguntas frecuentes sobre la hoja de trucos de Go
¿Esta hoja de trucos de Go es gratis?
Sí. Esta hoja de trucos de Go es completamente gratuita, sin necesidad de registrarse. Guárdala en favoritos y vuelve cuando necesites consultar una operación de slice, un patrón de canales o un método de struct.
¿Cuál es la diferencia entre := y var en Go?
var x = 0 declara una variable y funciona en cualquier parte, incluso a nivel de paquete. x := 0 es la declaración corta de variable: declara y asigna a la vez, infiere el tipo y solo se puede usar dentro de una función. Usa var cuando necesites un tipo explícito o una variable a nivel de paquete, y := para declaraciones locales concisas.¿Qué son las goroutines y los canales?
Una goroutine es un hilo ligero gestionado por el runtime de Go: inicias una escribiendo
go someFunc(). Los canales son tuberías tipadas que permiten a las goroutines comunicarse de forma segura: una goroutine envía con ch <- v y otra recibe con <-ch. Juntos son el modelo de concurrencia central de Go, resumido en el dicho "comparte memoria comunicándote".¿Puedo practicar Go en línea?
Sí. Abre el playground de Go para ejecutar cualquier fragmento de esta hoja de trucos en tu navegador, sin instalar ninguna cadena de herramientas de Go. Cuando quieras estructura, el curso interactivo y gratuito de Go de Coddy te lleva paso a paso desde las variables y los slices hasta las goroutines y los canales.
¿Esta hoja de trucos es buena para principiantes?
Sí. Está organizada desde los temas más comunes (variables, control de flujo, funciones) hasta los avanzados (goroutines, canales, manejo de errores), de modo que puedes usar las secciones de arriba desde el primer día e ir avanzando hacia el resto.
Recursos relacionados
Más hojas de referencia
