Corso Go

Le fondamenta: package, variabili, tipi, costanti, operatori e input/output con il pacchetto fmt.

1. 1.1Variabili e tipivar, dichiarazione corta `:=`, tipi base (int, float64, string, bool) e il concetto di tipizzazione statica.~10 min
2. 1.2Zero value e conversioni di tipoOgni variabile ha un valore di default; le conversioni sono esplicite (`int(x)`, `string(b)`).~10 min
3. 1.3Costanti e iota`const`, costanti non tipizzate, e il pattern `iota` per generare enumerazioni leggibili.~10 min
4. 1.4OperatoriAritmetici, di confronto, logici, bitwise; precedenza e differenze rispetto ad altri linguaggi.~8 min
5. 1.5Input/output con fmt`fmt.Println`, `fmt.Printf`, formato verbi (`%d`, `%s`, `%v`, `%T`) e quando preferire l’uno o l’altro.~10 min

Decisioni e ripetizioni: if con statement di init, l’unico `for`, switch idiomatico e gestione errori esplicita.

1. 2.1if, else e statement di initLa forma `if v := f(); v > 0 { ... }` e perché in Go non esiste l’operatore ternario.~10 min
2. 2.2for: l’unico cicloLe tre forme di `for`: tre-clausole, una-condizione (= while), infinito; uso di `break` e `continue`.~10 min
3. 2.3for...rangeIterare su slice, map e stringhe; il valore restituito è una copia, quando ignorare indice o valore con `_`.~10 min
4. 2.4switch idiomaticoNiente fallthrough implicito, espressioni complesse nei case, switch senza condizione come catena di if.~10 min
5. 2.5Errori: il pattern `if err != nil`Gli errori sono valori; il pattern fondamentale `if err != nil { return err }` e perché Go non ha eccezioni.~12 min

Funzioni come cittadini di prima classe: firma, ritorni multipli, parametri variadici, closure e `defer`.

1. 3.1Firma e parametriSintassi `func nome(p tipo) tipo`, passaggio per valore di default, parametri dello stesso tipo raggruppati.~10 min
2. 3.2Ritorni multipli e named returnsTornare più valori (`value, err`), il pattern dei named returns e quando NON usarlo.~12 min
3. 3.3Funzioni variadiche`func sum(nums ...int) int`, spread di slice con `slice...`, esempi tratti dalla stdlib.~10 min
4. 3.4Closure e funzioni come valoriFunzioni anonime che catturano variabili dal contesto esterno; pattern di adapter e factory.~12 min
5. 3.5`defer`: cleanup garantitoRinviare l’esecuzione fino al return; pattern `defer f.Close()`, ordine LIFO, gotcha con i loop.~12 min

Array, slice (la struttura più importante), map, rune nelle stringhe e ordinamento.

1. 4.1Array a lunghezza fissaSintassi `[N]T`, perché in Go i veri array si usano poco, conversione array → slice.~8 min
2. 4.2Slice: la struttura idiomatica`make`, `append`, len/cap, slicing `s[a:b]`, share dell’array sottostante e quando copiare.~15 min
3. 4.3Map: chiavi e valoriDichiarazione, accesso con comma-ok (`v, ok := m[k]`), `delete`, iterazione non deterministica.~12 min
4. 4.4Stringhe, byte e runeLe stringhe sono byte UTF-8; `range` produce rune; `len()` conta byte non caratteri.~12 min
5. 4.5Ordinamento con il pacchetto sort`sort.Ints`, `sort.Strings`, `sort.Slice` con funzione di confronto, stabilità.~10 min

Tipi dati composti: struct, metodi su receiver value o pointer, composizione (no inheritance) e tag.

1. 5.1Definire e usare uno struct`type Persona struct { Nome string; Eta int }`, inizializzazione posizionale vs nominale, struct anonimi.~12 min
2. 5.2Metodi: receiver value vs pointer`func (p Persona) Hello()` vs `func (p *Persona) Rename(n string)`; quando uno, quando l’altro.~14 min
3. 5.3Composizione (embedding)In Go non c’è ereditarietà: si compone embeddando un tipo dentro un altro. Promozione di metodi.~12 min
4. 5.4Tag dei campi e JSON`json:"nome,omitempty"`, marshalling/unmarshalling con `encoding/json`, errori comuni.~12 min
5. 5.5Pattern del costruttore `New...`Go non ha costruttori: la convenzione è una funzione `NewT(...) *T` che fa validazione e ritorna errori.~10 min

Interfacce strutturali (no implements esplicito), assertion, type switch e le interfacce standard `Stringer` e `error`.

1. 6.1Interfacce: definire un comportamentoUn’interfaccia è un insieme di metodi; chi li implementa la soddisfa automaticamente (duck typing statico).~12 min
2. 6.2Type assertion`v, ok := i.(*MyT)`, la forma con comma-ok per evitare panic, quando preferire un’assertion al type switch.~10 min
3. 6.3Type switch`switch v := x.(type) { case int: ... }` per dispatcher su tipo runtime.~10 min
4. 6.4L’interfaccia StringerImplementare `String() string` cambia come `fmt.Println` rappresenta il tuo tipo.~10 min
5. 6.5L’interfaccia error`error` è solo `Error() string`; creare errori custom, `errors.Is`, `errors.As`, `fmt.Errorf("%w", err)`.~14 min

Il modello di concorrenza di Go: goroutine leggere, channel per la comunicazione, `select`, sync e context.

1. 7.1Goroutine: parallelismo leggero`go f()`, costo di una goroutine, perché il main termina senza aspettare e come sincronizzare.~12 min
2. 7.2Channel: comunicazione tipata`ch := make(chan int)`, `ch <- v`, `v := <-ch`, channel buffered vs unbuffered, chiusura.~15 min
3. 7.3`select`: multiplexing di channelAspettare il primo channel pronto, case `default` per non bloccare, pattern timeout con `time.After`.~12 min
4. 7.4`sync.Mutex` e `sync.WaitGroup`Quando i channel non bastano: proteggere stato condiviso con Mutex, aspettare N goroutine con WaitGroup.~14 min
5. 7.5`context.Context`: cancellazione e deadlinePropagare cancellazione tra goroutine, `context.WithTimeout`, `ctx.Done()`, il pattern del primo parametro.~14 min

I pacchetti che userai ogni giorno: fmt, strings, strconv, io, os, time, encoding/json.

1. 8.1`fmt` avanzato`Sprintf`, `Fprintf`, verbi `%+v` e `%#v`, formattazione larghezza e precisione, flag `-` e `0`.~10 min
2. 8.2`strings` e `strconv``strings.Contains/Split/Join/TrimSpace`, `strconv.Itoa/Atoi/ParseInt/FormatFloat`.~12 min
3. 8.3`io` e `os`: file e stream`os.Open/Create/ReadFile/WriteFile`, le interfacce `io.Reader/Writer`, pattern `defer f.Close()`.~14 min
4. 8.4Il pacchetto `time``time.Now()`, durate, parsing con il layout di riferimento `2006-01-02 15:04:05`, timer e ticker.~12 min
5. 8.5`encoding/json``json.Marshal/Unmarshal`, struct tag, `json.Decoder/Encoder` per stream, errori di parsing.~14 min

Lo strumento `go test`, table-driven test, benchmark, gestione delle dipendenze con `go mod` e build tag.

1. 9.1Il pacchetto `testing`File `*_test.go`, funzioni `TestXxx(t *testing.T)`, `t.Error` vs `t.Fatal`, `go test ./...`.~12 min
2. 9.2Table-driven testIl pattern idiomatico: slice di struct anonimi con input e output attesi, `t.Run(name, ...)` per sub-test.~14 min
3. 9.3Benchmark e profiliFunzioni `BenchmarkXxx(b *testing.B)`, il ciclo `for i := 0; i < b.N; i++`, `go test -bench=.`.~12 min
4. 9.4Go modules`go mod init`, `go get`, semantic import versioning, lockfile `go.sum`, `go mod tidy`.~12 min
5. 9.5Build constraint e tagLa direttiva `//go:build ...` per cross-platform, separare codice di test/integration, esempi reali.~10 min

Naming, gestione errori avanzata, generics (Go 1.18+) e due mini-progetti: CLI e server HTTP.

1. 10.1Naming convention e stilePascalCase per export, camelCase per locali, nomi corti negli scope corti, `gofmt` non si discute.~10 min
2. 10.2Gestione errori idiomaticaErrori sentinel (`io.EOF`), errori custom con `Unwrap`, wrapping con `%w`, quando usare `panic`.~14 min
3. 10.3Generics (Go 1.18+)Type parameter `func Map[T, U any](s []T, f func(T) U) []U`, vincoli (`comparable`, custom), trade-off.~15 min
4. 10.4Mini-progetto: una CLI con flagPacchetto `flag`, comandi e sotto-comandi, exit code, `log` vs `fmt` per gli output.~18 min
5. 10.5Mini-progetto: un server HTTP`net/http`, handler e router minimale, middleware come decorator, graceful shutdown con context.~18 min