Du-te la curs

Bazele: pachete, variabile, tipuri, constante, operatori și intrare/ieșire cu pachetul fmt.

1. 1.1Variabile și tipurivar, declarația scurtă `:=`, tipurile de bază (int, float64, string, bool) și conceptul de tastare statică.~10 min
2. 1.2Valoare zero și conversii de tipFiecare variabilă are o valoare implicită; conversiile sunt explicite (`int(x)`, `string(b)`).~10 min
3. 1.3Constante și iota`const`, constante netipizate și modelul `iota` pentru generarea de enumerari care pot fi citite.~10 min
4. 1.4OperatoriAritmetică, comparație, logică și biți; precedență și diferențe față de alte limbi.~8 min
5. 1.5Intrare/ieșire cu fmt`fmt.Println`, `fmt.Printf`, verbe de format (`%d`, `%s`, `%v`, `%T`) și când să preferați unul față de celălalt.~10 min

Decizii și repetări: dacă cu instrucțiuni init, singurul „for”, comutare idiomatică și tratarea explicită a erorilor.

1. 2.1declarațiile if, else și init`dacă v := f(); v > 0 { ... }` și de ce Go nu are operator ternar.~10 min
2. 2.2pentru: singura buclăCele trei forme de „pentru”: trei clauze, condiție unică (= în timp ce) și infinit; folosind `break` și `continue`.~10 min
3. 2.3pentru...gamăIterați peste felii, hărți și șiruri de caractere; valoarea returnată este o copie, când să ignore indexul sau valoarea cu `_`.~10 min
4. 2.4Comutator idiomaticFără cădere implicită, expresii complexe în cazuri, comutare fără o condiție ca un lanț de if.~10 min
5. 2.5Erori: modelul `if err != nil`Erorile sunt valori; modelul fundamental `if err != nil { return err }` și de ce Go nu are excepții.~12 min

Funcționează ca cetățeni de primă clasă: semnături, returnări multiple, parametri variadici, închideri și „amânare”.

1. 3.1Semnătura și parametriiSintaxa `func name(p type) type`, pass-by-value implicit, parametrii de același tip grupați împreună.~10 min
2. 3.2Returnări multiple și returnări denumiteÎntoarce mai multe valori (`value, err`), modelul denumit returnează și când NU trebuie utilizat.~12 min
3. 3.3Funcții variadice`func sum(nums ...int) int`, răspândirea unei felii cu `slice...`, exemple din libbre-ul std.~10 min
4. 3.4Închideri și funcții ca valoriFuncții anonime care captează variabile din contextul înconjurător; adaptor și modele din fabrică.~12 min
5. 3.5`defer`: curățare garantatăAmână execuția până la returnare; modelul `defer f.Close()`, ordinea LIFO, s-au găsit în bucle.~12 min

Matrice, felii (cea mai importantă structură), hărți, rune în interiorul șirurilor și sortare.

1. 4.1Matrice cu lungime fixăSintaxa `[N]T`, de ce matricele reale sunt rareori folosite în Go, conversie din matrice în felie.~8 min
2. 4.2Felii: structura idiomatică`make`, `append`, len/cap, tăierea `s[a:b]`, partajarea matricei de bază și când să copiați.~15 min
3. 4.3Hărți: chei și valoriDeclarație, acces virgulă-ok (`v, ok := m[k]`), `delete`, iterație nedeterministă.~12 min
4. 4.4Șiruri, octeți și runeȘirurile sunt UTF-8 octeți; `range` produce rune; `len()` numără octeții, nu caracterele.~12 min
5. 4.5Sortare cu pachetul de sortare`sort.Ints`, `sort.Strings`, `sort.Slice` cu o funcție de comparație, stabilitate.~10 min

Tipuri de date compuse: structuri, metode pe receptorii de valoare sau pointer, compoziție (fără moștenire) și etichete.

1. 5.1Definirea și utilizarea unei structuri`type Person struct { Nume șir; Age int }`, inițializare pozițională vs numită, structuri anonime.~12 min
2. 5.2Metode: valoare vs receptor pointer`func (p Person) Hello()` vs `func (p *Person) Redenumiți(n șir)`; când să folosești una sau alta.~14 min
3. 5.3Compoziție (încorporare)Go nu are moștenire: compuneți prin încorporarea unui tip în altul. Promovarea metodei.~12 min
4. 5.4Etichete de câmp și JSON`json:"name,omitempty"`, marshalling/unmarshalling cu `encoding/json`, greșeli frecvente.~12 min
5. 5.5Modelul constructor `Nou...`Go nu are constructori: convenția este o funcție `NewT(...) *T` care validează și returnează erori.~10 min

Interfețe structurale (fără implemente explicite), aserțiuni, comutatoare de tip și interfețe standard „Stringer” și „error”.

1. 6.1Interfețe: definirea unui comportamentO interfață este un set de metode; oricine le implementează o satisface automat (dactilare statică de rață).~12 min
2. 6.2Tip afirmație`v, ok := i.(*MyT)`, forma virgulă-ok pentru a evita panica, când să preferați o afirmație față de un comutator de tip.~10 min
3. 6.3Comutator de tip`switch v := x.(type) { case int: ... }` pentru a trimite pe tipul runtime.~10 min
4. 6.4Interfața StringerImplementarea `String() string` schimbă modul în care `fmt.Println` reprezintă tipul tău.~10 min
5. 6.5Interfața de eroare`eroare` este doar `șir de eroare()`; crearea de erori personalizate, `errors.Is`, `errors.As`, `fmt.Errorf("%w", err)`.~14 min

Modelul de concurență Go: rutine ușoare, canale de comunicare, „selectare”, sincronizare și context.

1. 7.1Goroutine: paralelism ușor`go f()`, costul unei goroutine, de ce ieșirile principale fără așteptare și cum se sincronizează.~12 min
2. 7.2Canale: comunicare tipizată`ch := make(chan int)`, `ch <- v`, `v := <-ch`, canale tamponate vs nebufferate, închidere.~15 min
3. 7.3`select`: multiplexarea canalelorAșteptați primul canal gata, cazul `default` pentru a evita blocarea, modelul de timeout cu `time.After`.~12 min
4. 7.4`sync.Mutex` și `sync.WaitGroup`Când canalele nu sunt suficiente: protejați starea partajată cu un Mutex, așteptați N goroutine cu un WaitGroup.~14 min
5. 7.5`context.Context`: anulare și termene limităPropagați anularea prin goroutine, `context.WithTimeout`, `ctx.Done()`, modelul primului parametru.~14 min

Pachetele pe care le veți folosi în fiecare zi: fmt, strings, strconv, io, os, time, encoding/json.

1. 8.1`fmt` avansat`Sprintf`, `Fprintf`, verbele `%+v` și `%#v`, formatare de lățime și precizie, steaguri `-` ș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`: fișiere și fluxuri`os.Open/Create/ReadFile/WriteFile`, interfețele `io.Reader/Writer`, modelul `defer f.Close()`.~14 min
4. 8.4Pachetul `timp``time.Now()`, durate, analizare cu aspectul de referință `2006-01-02 15:04:05`, cronometre și tickere.~12 min
5. 8.5`encoding/json``json.Marshal/Unmarshal`, etichete struct, `json.Decoder/Encoder` pentru fluxuri, erori de analiză.~14 min

Instrumentul `go test`, teste bazate pe tabele, benchmark-uri, managementul dependențelor cu `go mod` și etichete de compilare.

1. 9.1Pachetul `testare`Fișiere `*_test.go`, funcții `TestXxx(t *testing.T)`, `t.Error` vs `t.Fatal`, `go test ./...`.~12 min
2. 9.2Teste bazate pe tabelModelul idiomatic: o porțiune de structuri anonime cu intrări și ieșiri așteptate, `t.Run(name, ...)` pentru sub-teste.~14 min
3. 9.3Benchmark-uri și profileFuncțiile `BenchmarkXxx(b *testare.B)`, `for i := 0; i < b.N; bucla i++`, `go test -bench=.`.~12 min
4. 9.4Go module`go mod init`, `go get`, versiunea de import semantic, fișierul de blocare `go.sum`, `go mod tidy`.~12 min
5. 9.5Construiți constrângeri și eticheteDirectiva `//go:build ...` pentru build-uri pe mai multe platforme, separând codul de testare/integrare, exemple din lumea reală.~10 min

Denumirea, gestionarea avansată a erorilor, generice (Go 1.18+) și două mini-proiecte: un CLI și un server HTTP.

1. 10.1Convenții de denumire și stilPascalCase pentru exporturi, camelCase pentru localnici, nume scurte în domenii scurte, `gofmt` nu este negociabil.~10 min
2. 10.2Tratarea erorilor idiomaticeErori Sentinel (`io.EOF`), erori personalizate cu `Unwrap`, împachetare cu `%w`, când să folosiți `panic`.~14 min
3. 10.3Generic (Go 1.18+)Parametri de tip `func Map[T, U any](s []T, f func(T) U) []U`, constrângeri (`comparabil`, personalizat), compromisuri.~15 min
4. 10.4Mini-proiect: un CLI cu steaguriPachetul `flag`, comenzi și sub-comenzi, coduri de ieșire, `log` vs `fmt` pentru ieșire.~18 min
5. 10.5Mini-proiect: un server HTTP`net/http`, handler și router minim, middleware ca decoratori, închidere grațioasă cu context.~18 min