Cours de langage Go

Leçon 1 • Fondamentaux du contrôle de flux

Couvre les instructions if/else, les boucles for et les instructions switch comme boîte à outils complète de contrôle de flux de Go. Met en lumière l'omission délibérée par Go des boucles while et do-while.

Leçon 2 • Historique et philosophie de conception de Go

Couvre les origines de Go chez Google, ses objectifs de simplicité et de performance, et comment ces objectifs façonnent chaque décision du langage. Établit le contexte pour tous les choix syntaxiques ultérieurs.

Leçon 3 • Structure du programme et points d'entrée

Explique les déclarations de paquets, la fonction main et les instructions d'importation. Fournit le squelette structurel que tout programme Go doit suivre.

Leçon 4 • Installation et configuration de la chaîne d'outils

Décrit le téléchargement de Go, la configuration de GOPATH et GOROOT, et la vérification de l'installation. Établit l'environnement de travail nécessaire pour chaque exercice ultérieur.

Leçon 1 • Fonctions de première classe et d'ordre supérieur

Traite les fonctions comme des valeurs : affectation, passage et retour. Prépare les étudiants aux fermetures et aux schémas fonctionnels utilisés dans les chapitres suivants.

Leçon 2 • Définition et appel de fonctions

Couvre les signatures de fonctions, le passage de paramètres et les valeurs de retour. Établit les conventions d'appel qui sous-tendent toute l'organisation du code Go.

Leçon 3 • Valeurs de retour multiples

Explique comment les fonctions Go renvoient plusieurs valeurs et pourquoi ce schéma remplace les exceptions. Permet directement la gestion d'erreurs idiomatique présentée ensuite.

Leçon 4 • Gestion d'erreurs idiomatique

Couvre l'interface error, les erreurs sentinelles et l'encapsulation avec fmt.Errorf. Établit la discipline de vérification explicite des erreurs, centrale dans le code Go de production.

Leçon 1 • Cartes

Couvre la création de maps, les opérations CRUD et le comportement de valeur nulle. Les maps sont largement utilisées dans la configuration, la mise en cache et les schémas de recherche tout au long du cours.

Leçon 2 • Tableaux et Slices

Distingue les tableaux de taille fixe des slices dynamiques et explique le modèle de tableau sous-jacent. La maîtrise des slices est un prérequis pour la manipulation idiomatique des données en Go.

Leçon 3 • Structures et étiquettes de structure

Définit les structures comme le type d'enregistrement principal de Go et introduit les étiquettes de champ pour la sérialisation. Les structures sont la base des méthodes et des interfaces dans le chapitre suivant.

Leçon 4 • Pointeurs et adressage mémoire

Explique la syntaxe des pointeurs, le déréférencement et quand utiliser les pointeurs plutôt que les valeurs. L'utilisation correcte des pointeurs est essentielle pour les méthodes avec types récepteurs et le passage efficace de données.

Leçon 1 • Définition et implémentation d'interfaces

Introduit la satisfaction implicite d'interface et la puissance des petites interfaces. Les étudiants implémentent des interfaces standard comme io.Reader et fmt.Stringer.

Leçon 2 • Assertions de type et commutateurs de type

Couvre l'inspection de type à l'exécution via les assertions et les commutateurs. Ces techniques sont nécessaires pour travailler avec les valeurs d'interface renvoyées par les fonctions de la bibliothèque standard.

Leçon 3 • L'interface vide et un aperçu des génériques

Explique interface{} et any comme types universels, puis présente les paramètres de type. Fait le pont entre le polymorphisme classique de Go et le système de génériques introduit dans Go 1.18.

Leçon 4 • Méthodes et types de récepteurs

Attache des fonctions aux types en utilisant des récepteurs de valeur et de pointeur. Le choix du récepteur affecte directement la sémantique de mutation et la satisfaction d'interface présentée ensuite.

Leçon 1 • Principes d'organisation des paquets

Couvre les conventions de nommage, les identifiants exportés versus non exportés et la cohésion des paquets. Une bonne conception de paquets prévient les problèmes de couplage abordés dans les sujets d'architecture ultérieurs.

Leçon 2 • Commandes du système de construction et de la chaîne d'outils

Passe en revue go build, go install, go vet et go fmt comme pipeline de construction principal. L'automatisation de ces commandes est fondamentale pour les pipelines CI/CD présentés plus tard.

Leçon 3 • Écriture et exécution de tests

Introduit le paquet testing, les tests pilotés par tableaux et les indicateurs go test. La discipline de test établie ici est étendue dans le chapitre supplémentaire sur les tests avancés.

Leçon 4 • Ajout et gestion des dépendances

Décrit l'ajout, la mise à niveau et la suppression de paquets tiers. Couvre les commandes go get et go mod tidy utilisées dans les workflows de développement quotidiens.

Leçon 1 • Détection et prévention des conditions de course

Utilise le détecteur de course et explique le modèle mémoire de Go pour identifier et corriger les conditions de course. Un code sans condition de course est un prérequis pour les schémas concurrents du chapitre suivant.

Leçon 2 • Primitives de synchronisation

Introduit sync.Mutex, sync.RWMutex, sync.WaitGroup et sync.Once. Ces primitives gèrent les scénarios d'état partagé où les canaux ne sont pas la solution appropriée.

Leçon 3 • Canaux pour la communication

Couvre les canaux non tamponnés et tamponnés, la sémantique d'envoi/réception et la direction des canaux. Les canaux sont le mécanisme principal de Go pour le partage sécurisé de données entre goroutines.

Leçon 4 • Instruction Select et multiplexage

Enseigne l'instruction select pour attendre simultanément plusieurs opérations sur des canaux. Permet les schémas de temporisation et les conceptions fan-in utilisés dans les services réels.

Leçon 1 • JSON et encodage des données

Enseigne encoding/json pour le marshaling et l'unmarshaling de structures. La gestion de JSON est requise pour toutes les API REST et les systèmes de configuration construits dans les chapitres suivants.

Leçon 2 • Contexte pour l'annulation et les échéances

Explique context.Context, l'annulation et la propagation des échéances à travers les limites des API. Le contexte est obligatoire pour les gestionnaires HTTP de production et les appels de base de données.

Leçon 3 • Journalisation et configuration de l'environnement

Couvre le paquet log, la journalisation structurée avec log/slog et la lecture des variables d'environnement. Une observabilité et une configuration appropriées sont essentielles pour les services déployables.

Leçon 4 • Notions de base du client et du serveur HTTP

Introduit net/http pour effectuer des requêtes et servir des réponses. Fournit la base pour le développement complet d'API REST présenté dans le chapitre appliqué.

Leçon 1 • Conteneurisation et déploiement de services Go

Construit des images Docker minimales en utilisant des builds multi-étapes et discute des cibles de déploiement. Achève le chemin du code source à un service de production opérationnel et observable.

Leçon 2 • Accès aux bases de données avec database/sql

Couvre le regroupement de connexions, les instructions préparées et la gestion des transactions en utilisant database/sql. Fournit la couche de persistance des données requise par la plupart des services de production.

Leçon 3 • Conception et implémentation d'API REST

Construit une API REST complète en utilisant net/http et un routeur, en appliquant des schémas d'intergiciel et de gestionnaire. Consolide les compétences en HTTP, JSON et contexte des chapitres précédents.

Leçon 4 • Arrêt gracieux et gestion des signaux

Implémente la gestion des signaux OS et l'arrêt du serveur avec les échéances de contexte. Empêche la perte de données et les erreurs de connexion lorsque les conteneurs ou les processus sont redémarrés.