Kurs Go

Fundamenty: pakiety, zmienne, typy, stałe, operatory oraz wejście/wyjście z pakietem fmt.

1. 1.1Zmienne i typyvar, krótka deklaracja `:=`, typy podstawowe (int, float64, string, bool) i koncepcja statycznego typowania.~10 min
2. 1.2Zero Value i konwersje typówKażda zmienna ma domyślną wartość; konwersje są jawne (`int(x)`, `string(b)`).~10 min
3. 1.3Stałe i iota`const`, stałe nietypowane i wzorzec `iota` do generowania czytelnych wyliczeń.~10 min
4. 1.4OperatoryArytmetyczne, porównania, logiczne i bitowe; priorytet i różnice w stosunku do innych języków.~8 min
5. 1.5Wejście/wyjście z fmt`fmt.Println`, `fmt.Printf`, operatory formatowania (`%d`, `%s`, `%v`, `%T`) i kiedy preferować jeden nad drugim.~10 min

Decyzje i pętle: if z instrukcją inicjującą, jedyna pętla `for`, idiomatyczny switch oraz jawna obsługa błędów.

1. 2.1if, else i instrukcje inicjująceForma `if v := f(); v > 0 { ... }` i dlaczego Go nie ma operatora trójargumentowego.~10 min
2. 2.2for: jedyna pętlaThe three forms of `for`: three-clause, single-condition (= while), and infinite; using `break` and `continue`.~10 min
3. 2.3for...rangeIteracja po slices, maps i strings; zwracana wartość jest kopią, kiedy ignorować indeks lub wartość za pomocą `_`.~10 min
4. 2.4Idiomatyczny switchBrak niejawnego przechodzenia (fallthrough), złożone wyrażenia w case, switch bez warunku jako łańcuch if.~10 min
5. 2.5Błędy: wzorzec `if err != nil`Błędy są wartościami; podstawowy wzorzec `if err != nil { return err }` i dlaczego Go nie ma wyjątków.~12 min

Funkcje jako obywatele pierwszej kategorii: sygnatury, wielokrotne zwracane wartości, parametry wariadyczne, domknięcia i `defer`.

1. 3.1Sygnatura i parametrySkładnia `func name(p type) type`, domyślne przekazywanie przez wartość, parametry tego samego typu pogrupowane razem.~10 min
2. 3.2Wielokrotne zwracane wartości i nazwane zwracane wartościZwracanie wielu wartości (`value, err`), wzorzec nazwanych wartości zwracanych i kiedy go NIE używać.~12 min
3. 3.3Funkcje wariadyczne`func sum(nums ...int) int`, rozpakowywanie slice za pomocą `slice...`, przykłady ze stdlib.~10 min
4. 3.4Domknięcia i funkcje jako wartościFunkcje anonimowe przechwytujące zmienne z otaczającego kontekstu; wzorce adaptera i fabryki.~12 min
5. 3.5`defer`: gwarantowane czyszczenieOdłożenie wykonania do momentu wyjścia; wzorzec `defer f.Close()`, kolejność LIFO, pułapki wewnątrz pętli.~12 min

Tablice, wycinki (najważniejsza struktura), mapy, runy wewnątrz ciągów znaków oraz sortowanie.

1. 4.1Tablice o stałej długościSkładnia `[N]T`, dlaczego prawdziwe tablice są rzadko używane w Go, konwersja tablicy na slice.~8 min
2. 4.2Slices: idiomatyczna struktura`make`, `append`, len/cap, wycinanie `s[a:b]`, dzielenie współdzielonej tablicy i kiedy kopiować.~15 min
3. 4.3Mapy: klucze i wartościDeklaracja, dostęp z przecinkiem `ok` (`v, ok := m[k]`), `delete`, niedeterministyczna iteracja.~12 min
4. 4.4Ciągi znaków, bajty i runyCiągi znaków to bajty UTF-8; `range` zwraca runy; `len()` liczy bajty, nie znaki.~12 min
5. 4.5Sortowanie z pakietem sort`sort.Ints`, `sort.Strings`, `sort.Slice` z funkcją porównującą, stabilność.~10 min

Złożone typy danych: struktury, metody na odbiorcach wartościowych lub wskaźnikowych, kompozycja (brak dziedziczenia) i tagi.

1. 5.1Definiowanie i używanie struktur`type Person struct { Name string; Age int }`, inicjalizzazione pozycyjna vs nazwana, struktury anonimowe.~12 min
2. 5.2Metody: odbiorca wartościowy vs wskaźnikowy`func (p Person) Hello()` vs `func (p *Person) Rename(n string)`; kiedy używać jednego lub drugiego.~14 min
3. 5.3Kompozycja (osadzanie)Go nie ma dziedziczenia: komponujesz poprzez osadzanie jednego typu w drugim. Promowanie metod.~12 min
4. 5.4Tagi pól i JSON`json:"name,omitempty"`, marshalling/unmarshalling with `encoding/json`, common mistakes.~12 min
5. 5.5Wzorzec konstruktora `New...`Go nie ma konstruktorów: konwencja to funkcja `NewT(...) *T`, która waliduje i zwraca błędy.~10 min

Interfejsy strukturalne (brak jawnego implementowania), asercje, przełączniki typów (type switch) oraz standardowe interfejsy `Stringer` i `error`.

1. 6.1Interfejsy: definiowanie zachowaniaInterfejs to zestaw metod; ktokolwiek je implementuje, automatycznie go spełnia (statyczne duck typing).~12 min
2. 6.2Asercja typu`v, ok := i.(*MyT)`, forma z przecinkiem `ok` dla uniknięcia paniki, kiedy preferować asercję nad type switch.~10 min
3. 6.3Przełącznik typów (type switch)`switch v := x.(type) { case int: ... }` do rozdzielania typów w czasie wykonywania.~10 min
4. 6.4Interfejs StringerImplementacja `String() string` zmienia sposób, w jaki `fmt.Println` reprezentuje Twój typ.~10 min
5. 6.5Interfejs error`error` to po prostu `Error() string`; tworzenie własnych błędów, `errors.Is`, `errors.As`, `fmt.Errorf("%w", err)`.~14 min

Model współbieżności Go: lekkie goroutines, kanały do komunikacji, instrukcja `select`, synchronizacja i kontekst.

1. 7.1Goroutines: lekka współbieżność`go f()`, koszt goroutine, dlaczego main kończy działanie bez czekania i jak zsynchronizować.~12 min
2. 7.2Kanały: typowana komunikacja`ch := make(chan int)`, `ch <- v`, `v := <-ch`, kanały buforowane vs niebuforowane, zamykanie.~15 min
3. 7.3`select`: multipleksowanie kanałówOczekiwanie na pierwszy gotowy kanał, przypadek `default` w celu uniknięcia blokowania, wzorzec limitu czasu z `time.After`.~12 min
4. 7.4`sync.Mutex` i `sync.WaitGroup`Kiedy kanały nie wystarczają: ochrona współdzielonego stanu za pomocą Mutex, oczekiwanie na N goroutines z WaitGroup.~14 min
5. 7.5`context.Context`: anulowanie i limity czasuPropagowanie anulowania w goroutines, `context.WithTimeout`, `ctx.Done()`, wzorzec pierwszego parametru.~14 min

Pakiety, których będziesz używać na co dzień: fmt, strings, strconv, io, os, time, encoding/json.

1. 8.1Zaawansowane `fmt``Sprintf`, `Fprintf`, operatory `%+v` i `%#v`, formatowanie szerokości i precyzji, flagi `-` i `0`.~10 min
2. 8.2`strings` i `strconv``strings.Contains/Split/Join/TrimSpace`, `strconv.Itoa/Atoi/ParseInt/FormatFloat`.~12 min
3. 8.3`io` i `os`: pliki i strumienie`os.Open/Create/ReadFile/WriteFile`, interfejsy `io.Reader/Writer`, wzorzec `defer f.Close()`.~14 min
4. 8.4Pakiet time`time.Now()`, przedziały czasowe, parsowanie z układem odniesienia `2006-01-02 15:04:05`, timery i tickery.~12 min
5. 8.5`encoding/json``json.Marshal/Unmarshal`, tagi struktur, `json.Decoder/Encoder` dla strumieni, błędy parsowania.~14 min

Narzędzie `go test`, testy sterowane tabelami (table-driven), benchmarki, zarządzanie zależnościami z `go mod` oraz build tagi.

1. 9.1Pakiet testingPliki `*_test.go`, funkcje `TestXxx(t *testing.T)`, `t.Error` vs `t.Fatal`, `go test ./...`.~12 min
2. 9.2Testy sterowane tabelamiIdiomatyczny wzorzec: wycinek (slice) anonimowych struktur z wejściami i oczekiwanymi wyjściami, `t.Run(name, ...)` dla podtestów.~14 min
3. 9.3Benchmarki i profileFunkcje `BenchmarkXxx(b *testing.B)`, pętla `for i := 0; i < b.N; i++`, `go test -bench=.`.~12 min
4. 9.4Moduły Go`go mod init`, `go get`, semantyczne wersjonowanie importów, plik blokady `go.sum`, `go mod tidy`.~12 min
5. 9.5Ograniczenia i tagi budowaniaDyrektywa `//go:build ...` dla budowania wieloplatformowego, oddzielanie kodu testowego/integracyjnego, rzeczywiste przykłady.~10 min

Nazewnictwo, zaawansowana obsługa błędów, generyki (Go 1.18+) oraz dwa mini-projekty: CLI i serwer HTTP.

1. 10.1Konwencje nazewnictwa i stylPascalCase dla eksportów, camelCase dla zmiennych lokalnych, krótkie nazwy w wąskich zakresach, `gofmt` jest bezdyskusyjne.~10 min
2. 10.2Idiomatyczna obsługa błędówBłędy wartownicy (`io.EOF`), błędy niestandardowe z `Unwrap`, owijanie z `%w`, kiedy używać `panic`.~14 min
3. 10.3Generyki (Go 1.18+)Parametry typu `func Map[T, U any](s []T, f func(T) U) []U`, ograniczenia (`comparable`, własne), kompromisy.~15 min
4. 10.4Mini-projekt: CLI z flagamiPakiet `flag`, polecenia i podpolecenia, kody wyjścia, `log` vs `fmt` dla wyjścia.~18 min
5. 10.5Mini-projekt: serwer HTTP`net/http`, minimalny handler i router, middleware jako dekoratory, łagodne wyłączanie z kontekstem.~18 min