Cours de Go

Les fondations : packages, variables, types, constantes, opérateurs et entrées/sorties avec le package fmt.

1. 1.1Variables et typesvar, la déclaration courte `:=`, les types de base (int, float64, string, bool) et le concept de typage statique.~10 min
2. 1.2Valeur zéro et conversions de typeChaque variable a une valeur par défaut ; les conversions sont explicites (`int(x)`, `string(b)`).~10 min
3. 1.3Constantes et iota`const`, constantes non typées et le motif `iota` pour générer des énumérations lisibles.~10 min
4. 1.4OpérateursArithmétiques, de comparaison, logiques et bit à bit ; préséance et différences par rapport aux autres langages.~8 min
5. 1.5Entrées/sorties avec fmt`fmt.Println`, `fmt.Printf`, verbes de format (`%d`, `%s`, `%v`, `%T`) et quand préférer l'un ou l'autre.~10 min

Décisions et répétitions : if avec déclarations d'initialisation, l'unique `for`, switch idiomatique et gestion explicite des erreurs.

1. 2.1if, else et déclarations d'initialisationLa forme `if v := f(); v > 0 { ... }` et pourquoi Go n'a pas d'opérateur ternaire.~10 min
2. 2.2for : l'unique boucleThe three forms of `for`: three-clause, single-condition (= while), and infinite; using `break` and `continue`.~10 min
3. 2.3for...rangeItérer sur les slices, maps et strings ; la valeur retournée est une copie, quand ignorer l'index ou la valeur avec `_`.~10 min
4. 2.4Switch idiomatiquePas de fallthrough implicite, expressions complexes dans les cas, switch sans condition comme chaîne de if.~10 min
5. 2.5Erreurs : le motif `if err != nil`Les erreurs sont des valeurs ; le motif fondamental `if err != nil { return err }` et pourquoi Go n'a pas d'exceptions.~12 min

Les fonctions en tant que citoyens de première classe : signatures, retours multiples, paramètres variadiques, fermetures et `defer`.

1. 3.1Signature et paramètresSyntaxe `func name(p type) type`, passage par valeur par défaut, paramètres du même type regroupés.~10 min
2. 3.2Retours multiples et retours nommésRetourner plusieurs valeurs (`value, err`), le motif des retours nommés et quand ne pas l'utiliser.~12 min
3. 3.3Fonctions variadiques`func sum(nums ...int) int`, déballage d'une slice avec `slice...`, exemples de la stdlib.~10 min
4. 3.4Fermetures et fonctions comme valeursFonctions anonymes qui capturent des variables du contexte environnant ; motifs d'adaptateur et de fabrique.~12 min
5. 3.5defer : nettoyage garantiReporter l'exécution jusqu'au retour ; le motif `defer f.Close()`, ordre LIFO, pièges dans les boucles.~12 min

Tableaux, slices (la structure la plus importante), maps, runes dans les chaînes et tri.

1. 4.1Tableaux de taille fixeSyntaxe `[N]T`, pourquoi les vrais tableaux sont rarement utilisés en Go, conversion de tableau en slice.~8 min
2. 4.2Slices : la structure idiomatique`make`, `append`, len/cap, découpage `s[a:b]`, partage du tableau sous-jacent et quand copier.~15 min
3. 4.3Maps : clés et valeursDéclaration, accès avec vérification (`v, ok := m[k]`), `delete`, itération non déterministe.~12 min
4. 4.4Chaînes, octets et runesLes chaînes sont des octets UTF-8 ; `range` produit des runes ; `len()` compte les octets, pas les caractères.~12 min
5. 4.5Tri avec le package sort`sort.Ints`, `sort.Strings`, `sort.Slice` avec une fonction de comparaison, stabilité.~10 min

Types de données composés : structures, méthodes sur récepteur de valeur ou de pointeur, composition (pas d'héritage) et tags.

1. 5.1Définir et utiliser une struct`type Person struct { Name string; Age int }`, initialisation positionnelle vs nommée, structures anonymes.~12 min
2. 5.2Méthodes : récepteur de valeur vs pointeur`func (p Person) Hello()` vs `func (p *Person) Rename(n string)` ; quand utiliser l'un ou l'autre.~14 min
3. 5.3Composition (imbrication)Go n'a pas d'héritage : vous composez en imbriquant un type dans un autre. Promotion des méthodes.~12 min
4. 5.4Tags de champs et JSON`json:"name,omitempty"`, marshalling/unmarshalling with encoding/json, common mistakes.~12 min
5. 5.5Le motif de constructeur `New...`Go n'a pas de constructeur : la convention est une fonction `NewT(...) *T` qui valide et renvoie des erreurs.~10 min

Interfaces structurelles (pas d'implémentation explicite), assertions, commutateurs de type (type switch) et interfaces standard `Stringer` et `error`.

1. 6.1Interfaces : définir un comportementUne interface est un ensemble de méthodes ; quiconque les implémente la satisfait automatiquement (typage canard statique).~12 min
2. 6.2Assertion de type`v, ok := i.(*MyT)`, la forme de vérification pour éviter les paniques, quand préférer une assertion à un type switch.~10 min
3. 6.3Type switch`switch v := x.(type) { case int: ... }` pour distribuer selon le type d'écriture.~10 min
4. 6.4L'interface StringerImplémenter `String() string` modifie la façon dont `fmt.Println` représente votre type.~10 min
5. 6.5L'interface error`error` est juste `Error() string` ; création d'erreurs personnalisées, `errors.Is`, `errors.As`, `fmt.Errorf("%w", err)`.~14 min

Le modèle de concurrence de Go : goroutines légères, canaux pour la communication, `select`, synchronisation et contexte.

1. 7.1Goroutines : parallélisme léger`go f()`, le coût d'une goroutine, pourquoi le main se termine sans attendre et comment synchroniser.~12 min
2. 7.2Channels : communication typée`ch := make(chan int)`, `ch <- v`, `v := <-ch`, canaux avec tampon vs sans tampon, fermeture.~15 min
3. 7.3select : multiplexage de canauxAttendre le premier canal prêt, le cas `default` pour éviter le blocage, le motif de timeout avec `time.After`.~12 min
4. 7.4sync.Mutex et sync.WaitGroupQuand les canaux ne suffisent pas : protéger l'état partagé avec un Mutex, attendre N goroutines avec un WaitGroup.~14 min
5. 7.5context.Context : annulation et délaisPropager l'annulation à travers les goroutines, `context.WithTimeout`, `ctx.Done()`, le motif du premier paramètre.~14 min

Les packages que vous utiliserez tous les jours : fmt, strings, strconv, io, os, time, encoding/json.

1. 8.1fmt avancé`Sprintf`, `Fprintf`, les verbes `%+v` et `%#v`, formatage de largeur et de précision, les drapeaux `-` et `0`.~10 min
2. 8.2strings et strconv`strings.Contains/Split/Join/TrimSpace`, `strconv.Itoa/Atoi/ParseInt/FormatFloat`.~12 min
3. 8.3io et os : fichiers et flux`os.Open/Create/ReadFile/WriteFile`, les interfaces `io.Reader/Writer`, le motif `defer f.Close()`.~14 min
4. 8.4Le package time`time.Now()`, durées, analyse avec le format de référence `2006-01-02 15:04:05`, temporisateurs et tickers.~12 min
5. 8.5encoding/json`json.Marshal/Unmarshal`, tags de struct, `json.Decoder/Encoder` pour les flux, erreurs d'analyse.~14 min

L'outil go test, tests pilotés par les données (table-driven), benchmarks, gestion des dépendances avec go mod et balises de build.

1. 9.1Le package testing`*_test.go` fichiers, fonctions `TestXxx(t *testing.T)`, `t.Error` vs `t.Fatal`, `go test ./...`.~12 min
2. 9.2Tests pilotés par les donnéesLe motif idiomatique : une tranche de structures anonymes avec entrées et sorties attendues, `t.Run(name, ...)` pour les sous-tests.~14 min
3. 9.3Benchmarks et profils`BenchmarkXxx(b *testing.B)` fonctions, la boucle `for i := 0; i < b.N; i++`, `go test -bench=.`.~12 min
4. 9.4Modules Go`go mod init`, `go get`, versionnage sémantique des importations, le fichier de verrouillage `go.sum`, `go mod tidy`.~12 min
5. 9.5Contraintes et balises de buildLa directive `//go:build ...` pour les builds multiplateformes, la séparation du code de test/d'intégration, exemples concrets.~10 min

Conventions de nommage, gestion avancée des erreurs, génériques (Go 1.18+) et deux mini-projets : un CLI et un serveur HTTP.

1. 10.1Conventions de nommage et stylePascalCase pour les exports, camelCase pour les variables locales, noms courts pour les portées courtes, `gofmt` est non négociable.~10 min
2. 10.2Gestion idiomatique des erreursErreurs sentinelles (`io.EOF`), erreurs personnalisées avec `Unwrap`, emballage avec `%w`, quand utiliser `panic`.~14 min
3. 10.3Génériques (Go 1.18+)Paramètres de type `func Map[T, U any](s []T, f func(T) U) []U`, contraintes (`comparable`, personnalisées), compromis.~15 min
4. 10.4Mini-projet : un CLI avec drapeauxLe package `flag`, commandes et sous-commandes, codes de sortie, `log` vs `fmt` pour la sortie.~18 min
5. 10.5Mini-projet : un serveur HTTP`net/http`, gestionnaire et routeur minimaux, middleware comme décorateurs, arrêt gracieux avec contexte.~18 min