Documentación de Go
Referencia concisa y basada en ejemplos de Go. Lee el concepto, mira el código y practícalo en un recorrido de Coddy.
Inicia un recorrido guiado de GoPrimeros pasos
- ¿Qué es Go?Go (a menudo llamado Golang) es un lenguaje compilado y de tipado estático diseñado en Google para construir servidores y herramientas rápidos y fiables. Esta página explica qué es, para qué se usa y dónde se queda corto.
- Instalar GoCómo descargar e instalar Go en Windows, macOS y Linux, comprobar la instalación con go version, entender GOPATH y resolver el error "go: command not found".
- Hola mundoEl programa hola mundo de Go línea por línea: package main, el bloque import, func main y fmt.Println, además de cómo ejecutarlo y los errores de compilación con los que se topa primero cualquier principiante.
- go run y go buildQué hacen go run, go build y go install, cómo nombra Go el binario, cómo compilar para otras plataformas con GOOS y GOARCH, y las comprobaciones go fmt y go vet que conviene ejecutar antes de cada commit.
- Módulos de GoCómo funcionan los módulos de Go: crear uno con go mod init, elegir la ruta del módulo, añadir dependencias con go get, limpiar con go mod tidy, para qué sirve go.sum y replace para el desarrollo local.
- Paquetes e importsCómo funcionan los paquetes de Go: la cláusula package, importar paquetes estándar y de módulos, nombres exportados y no exportados, repartir un paquete en varios archivos, paquetes internal, alias de import, imports vacíos y el error "undefined" de go run main.go.
Fundamentos
- VariablesCómo declarar variables en Go con var y la forma corta :=, qué son los valores cero, la asignación múltiple y los errores de sombreado y de variables sin usar que pillan a quien empieza con Go.
- ConstantesCómo funciona const en Go: declarar constantes, la diferencia entre constantes con tipo y sin tipo, expresiones constantes con precisión arbitraria y por qué Go no tiene slices, maps ni structs constantes.
- Enums e iotaGo no tiene la palabra clave enum. Esta página muestra el sustituto idiomático: un tipo con nombre más un bloque const con iota, y cómo añadir String(), validación, parseo, flags de bits y soporte para JSON.
- Tipos de datosLos tipos integrados de Go: tamaños y rangos de los enteros, float32 y float64, bool, string, byte y rune, números complejos, valores cero y cómo imprimir el tipo de un valor con %T.
- Conversión de tiposCómo convertir entre tipos en Go: int a string y string a int con strconv, flotantes a enteros, conversiones numéricas con T(v), bytes y runes, la trampa de string(65) y el manejo de errores de conversión.
- StringsTrabajar con strings en Go: el paquete strings (Split, Join, Contains, Replace, Fields, TrimSpace, ToUpper), construir strings de forma eficiente con strings.Builder, raw strings multilínea, inmutabilidad y por qué len cuenta bytes.
- Runes y bytesQué significan rune y byte en Go, cómo guardan los strings el UTF-8, por qué len cuenta bytes, cómo range decodifica runes, cómo convertir entre string, []byte y []rune, y cómo trabajar con el paquete bytes.
- fmt.Printf y SprintfCómo imprime y formatea valores el paquete fmt de Go: Println frente a Printf, Sprintf y Errorf, la tabla completa de verbos de formato (%v, %+v, %d, %s, %q, %f, %T, %w y más), ancho, precisión y relleno.
Control de flujo
- if / elseCómo funcionan if, else if y else en Go: sin paréntesis, llaves obligatorias, el if con cláusula de inicio y su ámbito, el idioma if err != nil y los retornos tempranos en lugar del anidamiento profundo.
- Bucle forGo tiene una sola palabra clave para bucles, for, y cubre todo: el bucle contador de tres partes, el bucle while con solo condición, el bucle infinito y range sobre slices, maps, strings, channels, enteros y funciones. Además, break y continue con etiqueta y el cambio de las variables de bucle en Go 1.22.
- Bucle whileGo no tiene la palabra clave while. Un bucle for con solo una condición es el while de Go, un for sin condición es un bucle infinito y un do-while es un bucle infinito con la comprobación al final.
- Bucles rangeQué produce for range con slices, arrays, strings, maps, channels, enteros y funciones iteradoras, por qué la variable del valor es una copia, qué pasa si modificas un slice o un map mientras lo recorres y range sobre funciones en Go 1.23.
- Sentencia switchCómo funciona switch en Go: los casos no caen al siguiente por defecto, un caso puede enumerar varios valores, un switch sin condición sustituye a las cadenas if/else, el switch con sentencia de inicio, la palabra clave fallthrough y un vistazo a los type switches.
- Operador ternarioGo no tiene operador ternario (cond ? a : b). Esta página explica por qué, muestra el sustituto idiomático con if/else, cmp.Or para valores por defecto y una función genérica auxiliar, junto con la trampa que la hace distinta de un ternario de verdad.
Funciones
- FuncionesCómo declarar y llamar funciones en Go: parámetros, tipos de parámetro compartidos, valores de retorno, paso por valor y funciones como valores que puedes guardar y pasar.
- Valores de retorno múltiplesLas funciones de Go pueden devolver varios valores. Esta página cubre la sintaxis, la convención (valor, error), el idioma comma-ok, los resultados con nombre, los return vacíos y el identificador vacío.
- Funciones variádicasUna función variádica de Go acepta cualquier número de argumentos finales de un mismo tipo. Aprende la sintaxis ...T, cómo pasar un slice con s..., la trampa del slice compartido y cómo usa fmt.Println el ...any.
- ClosuresLas funciones anónimas de Go pueden capturar variables del ámbito que las rodea. Así se forman las closures: contadores, generadores, middleware y callbacks que conservan su propio estado.
- Sentencia deferdefer programa una llamada para que se ejecute cuando retorna la función que la contiene. Aprende el orden LIFO, cuándo se evalúan los argumentos, cerrar archivos y liberar mutexes, defer en bucles y modificar resultados con nombre.
- MétodosUn método es una función con receptor. Aprende a declarar métodos, cuándo usar un receptor por valor o por puntero, los conjuntos de métodos y las interfaces, y los métodos sobre tipos que no son structs.
Colecciones
- ArraysUn array de Go tiene una longitud fija que forma parte de su tipo, y se copia al asignarlo. Aprende a declarar, recorrer, comparar y pasar arrays, y por qué la mayor parte del código Go usa slices.
- SlicesLos slices son el tipo lista de uso diario en Go. Aprende make, append y el crecimiento, len frente a cap, cómo recortar comparte el array subyacente (y el bug que provoca), copy, el paquete slices, slices 2D y nil frente a vacío.
- MapsLos maps de Go guardan pares clave-valor con búsquedas rápidas. Aprende a crearlos, comprobar si existe una clave con comma-ok, borrar, recorrerlos (en orden aleatorio), ordenar las claves, guardar structs y evitar los panics del map nil y de las escrituras concurrentes.
- SetsGo no tiene un tipo set integrado. El idioma estándar es un map con valores de struct vacío. Aprende a añadir, comprobar y quitar elementos, la unión, la intersección y la diferencia, y cómo escribir un pequeño Set genérico.
- OrdenaciónOrdena slices en Go con slices.Sort y slices.SortFunc, ordena structs por uno o varios campos con cmp.Compare, conserva el orden de los elementos iguales con una ordenación estable y entiende el código antiguo con sort.Slice.
Structs, interfaces y genéricos
- StructsLos structs agrupan campos con nombre en un solo tipo. Aprende a definirlos e inicializarlos, los valores cero, los punteros a structs, los structs anónimos, la comparación, los struct tags y la convención del constructor NewX.
- PunterosUn puntero contiene la dirección de un valor. Aprende & y *, new, punteros a structs, por qué puedes devolver sin peligro un puntero a una variable local, cuándo usar punteros y el panic por desreferencia de un puntero nil.
- InterfacesLas interfaces de Go se cumplen de forma implícita: cualquier tipo con los métodos adecuados las implementa. Aprende las interfaces pequeñas como io.Reader y fmt.Stringer, la interfaz vacía any, la trampa de la interfaz nil y el principio de aceptar interfaces y devolver structs.
- Embedding de structsEl embedding coloca un tipo dentro de otro sin nombre de campo, así que sus campos y métodos se promueven al tipo exterior. Aprende cómo funciona la promoción, cómo incrustar interfaces, los conflictos de nombres y por qué el embedding no es herencia.
- Aserciones de tipoUna aserción de tipo saca el valor concreto de una interfaz. Aprende x.(T), la forma comma-ok que nunca provoca un panic, la aserción a otra interfaz, los type switches y errors.As para los errores envueltos.
- GenéricosLos genéricos (Go 1.18+) permiten que una función o un tipo funcione con muchos tipos sin perder la seguridad de tipos. Aprende los parámetros de tipo, las restricciones any, comparable y cmp.Ordered, restricciones propias con ~, tipos genéricos y cuándo no usarlos.
Errores
- Manejo de erroresGo maneja los errores como valores normales que devuelven las funciones. Aprende la interfaz error, if err != nil, errors.New y fmt.Errorf, devolver errores con contexto, comprobarlos con errors.Is y errors.As, y manejar cada error una sola vez.
- Errores personalizadosDefine errores centinela y tipos de error propios, envuelve errores con %w, compruébalos con errors.Is y errors.As, combina varios con errors.Join y escribe métodos Unwrap e Is cuando los necesites.
- panic y recoverUn panic detiene la ejecución normal y deshace la pila, ejecutando las llamadas diferidas. Aprende qué provoca los panics, cómo los detiene recover dentro de una función diferida, los mensajes de error del runtime que verás y cuándo provocar un panic es la decisión correcta.
Concurrencia
- GoroutinesCómo ejecutar funciones de forma concurrente con la palabra clave go, esperar a que terminen, recuperar sus resultados y evitar las carreras de datos, fugas y caídas que las goroutines ponen tan a mano.
- ChannelsCómo los channels de Go pasan valores entre goroutines: channels con y sin buffer, cerrarlos y recorrerlos con range, tipos direccionales, el error de deadlock y un pipeline construido con ellos.
- Sentencia selectCómo espera select sobre varias operaciones de channel a la vez: elegir entre los casos listos, envíos y recepciones no bloqueantes con default, timeouts con time.After y detener bucles con un channel de salida o un context.
- WaitGroupCómo espera sync.WaitGroup a que termine un conjunto de goroutines: las reglas de Add, Done y Wait, por qué hay que pasarlo por puntero, recoger resultados y errores, y un worker pool construido sobre él.
- MutexCómo proteger el estado compartido entre goroutines con sync.Mutex y sync.RWMutex, cuándo basta con sync/atomic, cómo sync.Once ejecuta la inicialización exactamente una vez y los errores de locking que provocan deadlocks.
- Paquete contextCómo context.Context transporta cancelación, deadlines y valores de la petición a través de un programa Go: Background, WithCancel, WithTimeout, WithValue, ctx.Done en select y context en servidores y clientes HTTP.
Biblioteca estándar
- Paquete timeCómo trabajar con fechas y horas en Go: time.Now y time.Sleep, aritmética con Duration, el layout de referencia 2006-01-02 15:04:05 para Format y Parse, zonas horarias, timestamps Unix, y timers y tickers.
- JSONCómo codificar y decodificar JSON en Go con encoding/json: Marshal y Unmarshal, struct tags como omitempty y omitzero, salida con sangría, decodificar en map[string]any, rechazar campos desconocidos y streaming con Decoder.
- Leer y escribir archivosCómo leer y escribir archivos en Go: os.ReadFile y os.WriteFile, leer línea a línea con bufio.Scanner, añadir al final con os.OpenFile, comprobar si un archivo existe y trabajar con directorios.
- Servidor HTTPCómo construir un servidor web con el paquete estándar net/http de Go: handlers, rutas de ServeMux con métodos y comodines en la ruta (Go 1.22), respuestas JSON, códigos de estado, middleware, timeouts y apagado ordenado.
- Cliente HTTPCómo hacer peticiones HTTP en Go con net/http: http.Get, leer y cerrar el body, comprobar los códigos de estado, timeouts de http.Client, peticiones con context y cabeceras, parámetros de consulta y enviar JSON por POST.
- Argumentos de línea de comandosCómo lee un programa Go su línea de comandos: os.Args, el paquete flag para opciones tipadas, subcomandos con FlagSet, variables de entorno con os.Getenv y os.LookupEnv, y códigos de salida con os.Exit.
- Expresiones regularesCómo usar expresiones regulares en Go con el paquete regexp: MustCompile, MatchString, FindString y FindAllString, grupos de captura y grupos con nombre, ReplaceAllString y los límites de la sintaxis RE2, como la falta de lookbehind.
- LoggingCómo registrar logs en Go: el clásico paquete log con sus flags y log.Fatal, y log/slog (Go 1.21) para logs estructurados con niveles, atributos clave-valor, handlers de texto y JSON, y loggers que llevan contexto con With.
Pruebas y estructura de proyectos
- TestingCómo testear código Go con el paquete estándar testing y go test: archivos _test.go, funciones TestXxx, t.Errorf frente a t.Fatalf, tests de tabla con t.Run, helpers y directorios temporales, cobertura, benchmarks con b.Loop y tests de ejemplo.
- Estructura de proyectoCómo organizar un proyecto Go: empieza plano, divide en paquetes cuando haya un motivo, usa cmd/ para varios binarios e internal/ para el código que nadie más debe importar, pon buenos nombres a los paquetes y deja los tests junto al código.
