Ga cursus

De basis: pakketten, variabelen, typen, constanten, operators en invoer/uitvoer met het fmt-pakket.

1. 1.1Variabelen en typenvar, de korte declaratie `:=`, basistypen (int, float64, string, bool) en het concept van statisch typen.~10 min
2. 1.2Geen waarde- en typeconversiesElke variabele heeft een standaardwaarde; conversies zijn expliciet (`int(x)`, `string(b)`).~10 min
3. 1.3Constanten en jota`const`, ongetypeerde constanten en het `iota`-patroon voor het genereren van leesbare opsommingen.~10 min
4. 1.4ExploitantenRekenen, vergelijken, logisch en bitgewijs; prioriteit en verschillen met andere talen.~8 min
5. 1.5Ingang/uitgang met fmt`fmt.Println`, `fmt.Printf`, formatteer werkwoorden (`%d`, `%s`, `%v`, `%T`) en wanneer u de ene boven de andere wilt verkiezen.~10 min

Beslissingen en herhalingen: indien met init-instructies, de enkele 'for', idiomatische schakelaar en expliciete foutafhandeling.

1. 2.1if, else en init-instructiesDe `if v := f(); v > 0 { ... }` vorm en waarom Go geen ternaire operator heeft.~10 min
2. 2.2voor: de enige lusDe drie vormen van 'for': drie clausules, enkele voorwaarde (= while) en oneindig; gebruik 'pauze' en 'doorgaan'.~10 min
3. 2.3voor... bereikHerhaal over segmenten, kaarten en tekenreeksen; de geretourneerde waarde is een kopie. Wanneer u de index of waarde negeert met `_`.~10 min
4. 2.4Idiomatische schakelaarGeen impliciete fallthrough, complexe uitdrukkingen in gevallen, schakelen zonder voorwaarde als een keten van if.~10 min
5. 2.5Fouten: het patroon `if err != nil`Fouten zijn waarden; het fundamentele patroon `if err != nil { return err }` en waarom Go geen uitzonderingen kent.~12 min

Functioneert als eersteklas burgers: handtekeningen, meerdere aangiften, variabele parameters, sluitingen en 'uitstel'.

1. 3.1Handtekening en parameters`func naam(p type) type` syntaxis, standaard pass-by-waarde, parameters van hetzelfde type gegroepeerd.~10 min
2. 3.2Meerdere retourzendingen en retourzendingen op naamHet retourneren van meerdere waarden (`value, err`), het genoemde retourneert patroon en wanneer het NIET moet worden gebruikt.~12 min
3. 3.3Variadische functies`func sum(nums ...int) int`, een slice verspreiden met `slice...`, voorbeelden uit de stdlib.~10 min
4. 3.4Afsluitingen en functies als waardenAnonieme functies die variabelen uit de omringende context vastleggen; adapter- en fabriekspatronen.~12 min
5. 3.5`defer`: gegarandeerde opruimingUitvoering uitstellen tot terugkomst; het patroon `defer f.Close()`, LIFO-volgorde, valstrikken in lussen.~12 min

Arrays, segmenten (de belangrijkste structuur), kaarten, runen binnen strings en sortering.

1. 4.1Arrays met vaste lengte`[N]T`-syntaxis, waarom echte arrays zelden worden gebruikt in Go, conversie van array naar slice.~8 min
2. 4.2Slices: de idiomatische structuur`make`, `append`, len/cap, `s[a:b]` in plakjes snijden, de onderliggende array delen en wanneer te kopiëren.~15 min
3. 4.3Kaarten: sleutels en waardenVerklaring, komma-ok toegang (`v, ok := m[k]`), `delete`, niet-deterministische iteratie.~12 min
4. 4.4Tekenreeksen, bytes en runenTekenreeksen zijn UTF-8-bytes; `bereik` levert runen op; `len()` telt bytes, geen karakters.~12 min
5. 4.5Sorteren met het sorteerpakket`sort.Ints`, `sort.Strings`, `sort.Slice` met een vergelijkingsfunctie, stabiliteit.~10 min

Samengestelde gegevenstypen: structuren, methoden voor waarde- of pointerontvangers, compositie (geen overerving) en tags.

1. 5.1Een structuur definiëren en gebruiken`type Persoon struct { Naamstring; Age int }`, positionele versus benoemde initialisatie, anonieme structuren.~12 min
2. 5.2Methoden: waarde versus aanwijzerontvanger`func (p Persoon) Hallo()` vs `func (p *Person) Hernoemen(n string)`; wanneer je het een of het ander moet gebruiken.~14 min
3. 5.3Samenstelling (inbedding)Go heeft geen erfenis: je componeert door het ene type in het andere in te bedden. Methode promotie.~12 min
4. 5.4Veldtags en JSON`json:"name,omitempty"`, marshalling/unmarshalling met `encoding/json`, veel voorkomende fouten.~12 min
5. 5.5Het constructorpatroon 'Nieuw...'Go heeft geen constructors: de conventie is een functie `NewT(...) *T` die fouten valideert en retourneert.~10 min

Structurele interfaces (geen expliciete implementaties), beweringen, typeschakelaars en de standaard 'Stringer'- en 'error'-interfaces.

1. 6.1Interfaces: gedrag definiërenEen interface is een reeks methoden; degene die ze implementeert, voldoet er automatisch aan (statisch duck-typen).~12 min
2. 6.2Typ bewering`v, ok := i.(*MyT)`, de komma-ok-vorm om paniek te voorkomen, wanneer je de voorkeur geeft aan een bewering boven een typewisseling.~10 min
3. 6.3Type schakelaar`switch v := x.(type) { case int: ... }` om het runtime-type te verzenden.~10 min
4. 6.4De Stringer-interfaceHet implementeren van `String() string` verandert hoe `fmt.Println` uw type vertegenwoordigt.~10 min
5. 6.5De foutinterface`error` is gewoon `Error() string`; aangepaste fouten maken, `errors.Is`, `errors.As`, `fmt.Errorf("%w", err)`.~14 min

Go's concurrency-model: lichtgewicht goroutines, kanalen voor communicatie, 'selecteren', synchronisatie en context.

1. 7.1Goroutines: lichtgewicht parallellisme`go f()`, de kosten van een goroutine, waarom hoofduitgangen zonder te wachten, en hoe te synchroniseren.~12 min
2. 7.2Kanalen: getypte communicatie`ch := make(chan int)`, `ch <- v`, `v := <-ch`, gebufferde versus niet-gebufferde kanalen, sluiten.~15 min
3. 7.3`select`: kanalen multiplexenWacht op het eerste kanaal dat gereed is, het 'standaard'-geval om blokkering te voorkomen, het time-outpatroon met 'time.After'.~12 min
4. 7.4`sync.Mutex` en `sync.WaitGroup`Als kanalen niet genoeg zijn: bescherm de gedeelde status met een Mutex, wacht op N goroutines met een WaitGroup.~14 min
5. 7.5`context.Context`: annulering en deadlinesVerspreid annulering over goroutines, `context.WithTimeout`, `ctx.Done()`, het patroon met de eerste parameter.~14 min

De pakketten die je elke dag gebruikt: fmt, strings, strconv, io, os, time, encoding/json.

1. 8.1Geavanceerde 'fmt'`Sprintf`, `Fprintf`, de `%+v` en `%#v` werkwoorden, breedte- en precisie-opmaak, de `-` en `0` vlaggen.~10 min
2. 8.2`strings` en `strconv``strings.Contains/Split/Join/TrimSpace`, `strconv.Itoa/Atoi/ParseInt/FormatFloat`.~12 min
3. 8.3`io` en `os`: bestanden en streams`os.Open/Create/ReadFile/WriteFile`, de `io.Reader/Writer` interfaces, het `defer f.Close()` patroon.~14 min
4. 8.4Het 'tijd'-pakket`time.Now()`, duur, parseren met de referentie-indeling `2006-01-02 15:04:05`, timers en tickers.~12 min
5. 8.5`codering/json``json.Marshal/Unmarshal`, struct-tags, `json.Decoder/Encoder` voor streams, parseerfouten.~14 min

De `go test`-tool, tabelgestuurde tests, benchmarks, afhankelijkheidsbeheer met `go mod` en build-tags.

1. 9.1Het `test`-pakket`*_test.go` bestanden, `TestXxx(t *testing.T)` functies, `t.Error` vs `t.Fatal`, `go test ./...`.~12 min
2. 9.2Tabelgestuurde testsHet idiomatische patroon: een stukje anonieme structuur met invoer en verwachte uitvoer, `t.Run(naam, ...)' voor subtests.~14 min
3. 9.3Benchmarks en profielen`BenchmarkXxx(b *testing.B)` functies, de `for i := 0; ik < b.N; i++` lus, `go test -bench=.`.~12 min
4. 9.4Ga modules`go mod init`, `go get`, semantisch importversiebeheer, het `go.sum` lockfile, `go mod netjes`.~12 min
5. 9.5Bouw beperkingen en tagsDe `//go:build ...` richtlijn voor platformonafhankelijke builds, waarbij test-/integratiecode en praktijkvoorbeelden worden gescheiden.~10 min

Naamgeving, geavanceerde foutafhandeling, generieke geneesmiddelen (Go 1.18+) en twee miniprojecten: een CLI en een HTTP-server.

1. 10.1Naamgevingsconventies en stijlPascalCase voor export, camelCase voor de lokale bevolking, korte namen in korte scopes, `gofmt` is niet onderhandelbaar.~10 min
2. 10.2Idiomatische foutafhandelingSentinel-fouten (`io.EOF`), aangepaste fouten met `Unwrap`, omloop met `%w`, wanneer `panic` moet worden gebruikt.~14 min
3. 10.3Generieke geneesmiddelen (Go 1.18+)Type parameters `func Map[T, U any](s []T, f func(T) U) []U`, beperkingen (`vergelijkbaar`, aangepast), afwegingen.~15 min
4. 10.4Miniproject: een CLI met vlaggenHet `flag`-pakket, opdrachten en subopdrachten, exitcodes, `log` versus `fmt` voor uitvoer.~18 min
5. 10.5Miniproject: een HTTP-server`net/http`, minimale handler en router, middleware als decorateurs, sierlijke afsluiting met context.~18 min