Curso de Go

Las bases: paquetes, variables, tipos, constantes, operadores y entrada/salida con el paquete fmt.

1. 1.1Variables y tiposvar, la declaración corta `:=`, tipos básicos (int, float64, string, bool) y el concepto de tipado estático.~10 min
2. 1.2Valor cero y conversiones de tipoCada variable tiene un valor por defecto; las conversiones son explícitas (`int(x)`, `string(b)`).~10 min
3. 1.3Constantes e iota`const`, constantes sin tipo y el patrón `iota` para generar enumeraciones legibles.~10 min
4. 1.4OperadoresAritméticos, de comparación, lógicos y a nivel de bits; precedencia y diferencias con otros lenguajes.~8 min
5. 1.5Entrada/salida con fmt`fmt.Println`, `fmt.Printf`, verbos de formato (`%d`, `%s`, `%v`, `%T`) y cuándo preferir uno sobre el otro.~10 min

Decisiones y repeticiones: if con declaraciones de inicio, el único `for`, switch idiomático y gestión de errores explícita.

1. 2.1if, else y declaraciones de inicioLa forma `if v := f(); v > 0 { ... }` y por qué Go no tiene operador ternario.~10 min
2. 2.2for: el único bucleThe three forms of `for`: three-clause, single-condition (= while), and infinite; using `break` and `continue`.~10 min
3. 2.3for...rangeIterar sobre slices, maps y strings; el valor retornado es una copia, cuándo ignorar el índice o el valor con `_`.~10 min
4. 2.4Switch idiomáticoSin fallthrough implícito, expresiones complejas en los cases, switch sin condición como una cadena de if.~10 min
5. 2.5Errores: el patrón `if err != nil`Los errores son valores; el patrón fundamental `if err != nil { return err }` y por qué Go no tiene excepciones.~12 min

Las funciones como ciudadanos de primera clase: firmas, retornos múltiples, parámetros variádicos, clausuras y `defer`.

1. 3.1Firma y parámetrosSintaxis `func name(p type) type`, paso por valor por defecto, parámetros del mismo tipo agrupados.~10 min
2. 3.2Retornos múltiples y retornos con nombreRetornar múltiples valores (`value, err`), el patrón de retornos con nombre y cuándo NO usarlo.~12 min
3. 3.3Funciones variádicas`func sum(nums ...int) int`, desempaquetado de un slice con `slice...`, ejemplos de la biblioteca estándar.~10 min
4. 3.4Clausuras y funciones como valoresFunciones anónimas que capturan variables del contexto circundante; patrones de adaptador y fábrica.~12 min
5. 3.5defer: limpieza garantizadaPosponer la ejecución hasta el retorno; el patrón `defer f.Close()`, orden LIFO, advertencias dentro de bucles.~12 min

Arrays, slices (la estructura más importante), maps, runas dentro de strings y ordenación.

1. 4.1Arrays de longitud fijaSintaxis `[N]T`, por qué los arrays reales se usan poco en Go, conversión de array a slice.~8 min
2. 4.2Slices: la estructura idiomática`make`, `append`, len/cap, rebanado `s[a:b]`, compartir el array subyacente y cuándo copiar.~15 min
3. 4.3Maps: claves y valoresDeclaración, acceso con verificación (`v, ok := m[k]`), `delete`, iteración no determinante.~12 min
4. 4.4Strings, bytes y runasLos strings son bytes UTF-8; `range` produce runas; `len()` cuenta bytes, no caracteres.~12 min
5. 4.5Ordenación con el paquete sort`sort.Ints`, `sort.Strings`, `sort.Slice` con función de comparación, estabilidad.~10 min

Tipos de datos compuestos: structs, métodos con receptor de valor o puntero, composición (sin herencia) y tags.

1. 5.1Definición y uso de un struct`type Person struct { Name string; Age int }`, inicialización posicional vs por nombre, structs anónimos.~12 min
2. 5.2Métodos: receptor de valor vs de puntero`func (p Person) Hello()` vs `func (p *Person) Rename(n string)`; cuándo usar uno u otro.~14 min
3. 5.3Composición (embebido)Go no tiene herencia: se compone embebiendo un tipo dentro de otro. Promoción de métodos.~12 min
4. 5.4Tags de campos y JSON`json:"name,omitempty"`, marshalling/unmarshalling with encoding/json, common mistakes.~12 min
5. 5.5El patrón de constructor `New...`Go no tiene constructores: la convención es una función `NewT(...) *T` que valida y retorna errores.~10 min

Interfaces estructurales (sin implements explícito), aserciones, type switches y las interfaces estándar `Stringer` y `error`.

1. 6.1Interfaces: definir un comportamientoUna interfaz es un conjunto de métodos; quien los implementa la satisface automáticamente (duck typing estático).~12 min
2. 6.2Aserción de tipo`v, ok := i.(*MyT)`, la forma de verificación para evitar pánicos, cuándo preferir una aserción sobre un type switch.~10 min
3. 6.3Type switch`switch v := x.(type) { case int: ... }` para despachar según el tipo en tiempo de ejecución.~10 min
4. 6.4La interfaz StringerImplementar `String() string` cambia cómo `fmt.Println` representa tu tipo.~10 min
5. 6.5La interfaz error`error` es solo `Error() string`; creación de errores personalizados, `errors.Is`, `errors.As`, `fmt.Errorf("%w", err)`.~14 min

El modelo de concurrencia de Go: gorutinas ligeras, canales para la comunicación, `select`, sincronización y contexto.

1. 7.1Gorutinas: paralelismo ligero`go f()`, el coste de una gorutina, por qué la función principal main termina sin esperar y cómo sincronizar.~12 min
2. 7.2Canales: comunicación tipada`ch := make(chan int)`, `ch <- v`, `v := <-ch`, canales con búfer vs sin búfer, cierre.~15 min
3. 7.3select: multiplexación de canalesEsperar al primer canal listo, el caso `default` para evitar el bloqueo, el patrón de timeout con `time.After`.~12 min
4. 7.4sync.Mutex y sync.WaitGroupCuando los canales no bastan: proteger el estado compartido con un Mutex, esperar a N gorutinas con un WaitGroup.~14 min
5. 7.5context.Context: cancelación y plazosPropagar la cancelación a través de las gorutinas, `context.WithTimeout`, `ctx.Done()`, el patrón del primer parámetro.~14 min

Los paquetes de uso diario: fmt, strings, strconv, io, os, time, encoding/json.

1. 8.1fmt avanzado`Sprintf`, `Fprintf`, los verbos `%+v` y `%#v`, formato de ancho y precisión, las banderas `-` y `0`.~10 min
2. 8.2strings y strconv`strings.Contains/Split/Join/TrimSpace`, `strconv.Itoa/Atoi/ParseInt/FormatFloat`.~12 min
3. 8.3io y os: archivos y flujos`os.Open/Create/ReadFile/WriteFile`, las interfaces `io.Reader/Writer`, el patrón `defer f.Close()`.~14 min
4. 8.4El paquete time`time.Now()`, duraciones, parseo con el diseño de referencia `2006-01-02 15:04:05`, temporizadores y tickers.~12 min
5. 8.5encoding/json`json.Marshal/Unmarshal`, tags de struct, `json.Decoder/Encoder` para flujos, errores de parseo.~14 min

La herramienta go test, pruebas basadas en tablas (table-driven), benchmarks, gestión de dependencias con go mod y etiquetas de compilación.

1. 9.1El paquete testing`*_test.go` archivos, funciones `TestXxx(t *testing.T)` funciones, `t.Error` vs `t.Fatal`, `go test ./...`.~12 min
2. 9.2Pruebas basadas en tablasEl patrón idiomático: un slice de structs anónimos con entradas y salidas esperadas, `t.Run(name, ...)` para subpruebas.~14 min
3. 9.3Benchmarks y perfiles`BenchmarkXxx(b *testing.B)` funciones, el bucle `for i := 0; i < b.N; i++`, `go test -bench=.`.~12 min
4. 9.4Módulos de Go`go mod init`, `go get`, versionado semántico de importaciones, el archivo de bloqueo `go.sum`, `go mod tidy`.~12 min
5. 9.5Restricciones y etiquetas de compilaciónLa directiva `//go:build ...` para compilaciones multiplataforma, separar código de prueba/integración, ejemplos reales.~10 min

Convenciones de nombres, gestión avanzada de errores, genéricos (Go 1.18+) y dos mini-proyectos: una CLI y un servidor HTTP.

1. 10.1Convenciones de nombres y estiloPascalCase para exportaciones, camelCase para locales, nombres cortos en ámbitos cortos, `gofmt` es innegociable.~10 min
2. 10.2Gestión idiomática de erroresErrores centinela (`io.EOF`), errores personalizados con `Unwrap`, envoltura con `%w`, cuándo usar `panic`.~14 min
3. 10.3Genéricos (Go 1.18+)Parámetros de tipo `func Map[T, U any](s []T, f func(T) U) []U`, restricciones (`comparable`, personalizadas), compensaciones.~15 min
4. 10.4Mini-proyecto: una CLI con banderasEl paquete `flag`, comandos y subcomandos, códigos de salida, `log` vs `fmt` para la salida.~18 min
5. 10.5Mini-proyecto: un servidor HTTP`net/http`, manejador y enrutador mínimos, middleware como decoradores, apagado ordenado con contexto.~18 min