Cours de langage Go

Leçon 1 • Notions essentielles du flux de contrôle

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

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

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

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

Explique les déclarations de paquetage, 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

Guide pour télécharger Go, configurer GOPATH et GOROOT, et vérifier 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 : les assigner, les passer et les retourner. Prépare les étudiants aux fermetures et aux modèles fonctionnels utilisés dans les chapitres ultérieurs.

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 retournent plusieurs valeurs et pourquoi ce modèle remplace les exceptions. Permet directement la gestion idiomatique des erreurs abordée ensuite.

Leçon 4 • Gestion idiomatique des erreurs

Couvre l'interface error, les erreurs sentinelles et l'encapsulation avec fmt.Errorf. Établit la discipline de vérification explicite des erreurs au cœur du code Go de production.

Leçon 1 • Cartes

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

Leçon 2 • Tableaux et tranches

Distingue les tableaux de taille fixe des tranches dynamiques et explique le modèle de tableau sous-jacent. La maîtrise des tranches 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 de récepteur et le passage efficace de données.

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

Présente 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 des assertions et des commutateurs. Ces techniques sont nécessaires pour travailler avec des valeurs d'interface retourné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 donne un aperçu des 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écepteur

Attache des fonctions à des 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 abordées ensuite.

Leçon 1 • Principes d'organisation des paquetages

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

Leçon 2 • Système de compilation et commandes de la chaîne d'outils

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

Leçon 3 • Rédaction et exécution de tests

Présente le paquetage testing, les tests pilotés par des tableaux et les indicateurs de 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

Guide pour ajouter, mettre à niveau et supprimer des paquetages tiers. Couvre les commandes go get et go mod tidy utilisées dans les flux de travail de développement quotidiens.

Leçon 1 • Détection et prévention des situations de compétition sur les données

Utilise le détecteur de situations de compétition et explique le modèle mémoire de Go pour identifier et corriger les situations de compétition sur les données. Un code sans situation de compétition est un prérequis pour les modèles 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 les goroutines.

Leçon 4 • Instruction Select et multiplexage

Enseigne l'instruction select pour attendre plusieurs opérations de canal simultanément. Permet les modèles de délai d'attente et les conceptions fan-in utilisés dans les services réels.

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

Enseigne encoding/json pour le marshaling et l'unmarshaling de structures. La gestion du JSON est requise pour chaque API REST et système de configuration construit dans les chapitres ultérieurs.

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 de l'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 paquetage log, la journalisation structurée avec log/slog et la lecture des variables d'environnement. Une observabilité et une configuration adéquates sont essentielles pour les services déployables.

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

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

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

Construit des images Docker minimales en utilisant des constructions en plusieurs étapes et discute des cibles de déploiement. Complète le chemin du code source à un service de production en cours d'exécution et observable.

Leçon 2 • Accès à la base 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 modèles d'intergiciel et de gestionnaire. Consolide les compétences 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 du système d'exploitation et l'arrêt du serveur avec des é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.