Cours de base en programmation Go

Leçon 1 • Installation et configuration de Go

Couvre l'installation de Go, la disposition de l'espace de travail et la configuration de la chaîne d'outils. Fournit les fondations opérationnelles dont dépend chaque chapitre suivant.

Leçon 2 • Opérateurs et expressions

Couvre les opérateurs arithmétiques, de comparaison, logiques et binaires. Les étudiants acquièrent la capacité de construire des expressions correctes dans tout contexte Go.

Leçon 3 • Variables, constantes et types de données

Enseigne les styles de déclaration de variables, les valeurs zéro et les types primitifs intégrés. Développe la conscience des types nécessaire pour chaque tâche de codage subséquente.

Leçon 4 • Utilisation de la chaîne d'outils Go

Explore les commandes go build, go fmt, go vet et go doc. Équipe les étudiants des outils de flux de travail quotidiens utilisés dans le développement Go professionnel.

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

Présente les signatures de fonctions, les paramètres et les valeurs de retour. Établit la brique de base pour le code Go modulaire utilisé tout au long du cours.

Leçon 2 • Boucles et itération

Couvre la boucle for dans toutes ses formes, y compris l'itération basée sur range. Fournit les outils d'itération nécessaires pour traiter les collections et les flux.

Leçon 3 • Defer, Panic et Recover

Explique les appels différés, la propagation de panique et les motifs de récupération. Les étudiants apprennent l'approche idiomatique de Go pour le nettoyage des ressources et le confinement des erreurs.

Leçon 4 • Fonctions de première classe et fermetures

Traite les fonctions comme des valeurs, couvrant les fonctions anonymes et les fermetures. Prépare les étudiants aux patrons d'ordre supérieur utilisés dans les chapitres suivants.

Leçon 1 • Tableaux en Go

Couvre la déclaration de tableaux de longueur fixe, l'indexation et la sémantique de valeur. Établit le modèle mémoire qui sous-tend le comportement des tranches dans les sections suivantes.

Leçon 2 • Patrons de tranches courants

Démontre les idiomes de filtrage, de déduplication et de modification sur place. Développe une boîte à outils pratique pour la manipulation de tranches utilisée dans les bases de code réelles.

Leçon 3 • Tranches : aspects internes et opérations

Explique les en-têtes de tranche, les tableaux sous-jacents et le comportement de croissance. La maîtrise de ceci prévient les bogues courants dans la manipulation de données tout au long du cours.

Leçon 4 • Structures comme enregistrements composites

Présente la déclaration de structure, l'accès aux champs, l'incorporation et les champs anonymes. Jette les bases du système de types exploré dans le prochain chapitre.

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

Enseigne go get, go mod tidy et la sélection de version de dépendance. Les étudiants maintiennent des graphes de dépendances propres et reproductibles dans des projets réels.

Leçon 2 • Publication et versionnage de modules

Explique le marquage de versions, les suffixes de version majeure et les proxy de modules. Prépare les étudiants à partager des bibliothèques réutilisables avec l'écosystème Go.

Leçon 3 • Modules Go et go.mod

Explique l'initialisation de module, le fichier go.mod et le versionnage sémantique. Établit le contrat de dépendance qui régit tous les projets Go modernes.

Leçon 4 • Principes d'organisation des paquetages

Couvre le nommage des paquetages, les identifiants exportés vs non exportés et la cohésion. Guide les étudiants vers des structures de paquetage qui évoluent avec la taille du projet.

Leçon 1 • Méthodes sur les types

Couvre les récepteurs de valeur et de pointeur, les ensembles de méthodes et la promotion via l'incorporation. Établit comment le comportement est attaché aux types en Go.

Leçon 2 • Meilleures pratiques de conception d'interfaces

Couvre les petites interfaces, accepter des interfaces/retourner des concrets et la pollution d'interfaces. Guide les étudiants vers des limites d'API maintenables et testables.

Leçon 3 • Interfaces de la bibliothèque standard

Examine les interfaces io.Reader, io.Writer, fmt.Stringer et error. Relie la théorie des interfaces aux interfaces que les étudiants rencontrent quotidiennement.

Leçon 4 • Assertions de type et switches de type

Enseigne les assertions de type sécurisées et non sécurisées et le dispatch par switch de type. Permet l'inspection de type à l'exécution nécessaire pour les patrons de gestionnaires génériques.

Leçon 1 • Bases de la journalisation et de l'observabilité

Présente la journalisation structurée avec les paquetages log et log/slog. Relie la gestion des erreurs à la visibilité opérationnelle dans les systèmes de production.

Leçon 2 • Encapsulation et désencapsulation d'erreurs

Couvre les chaînes d'erreurs, errors.Is, errors.As et les arbres de désencapsulation. Les étudiants apprennent à inspecter les erreurs superposées sans briser l'encapsulation.

Leçon 3 • Patrons de panique et de récupération

Revient sur panic et recover dans le contexte de la sécurité des limites de bibliothèque. Les étudiants savent quand convertir des paniques en erreurs aux surfaces d'API.

Leçon 4 • Le modèle d'erreur en Go

Explique l'interface error, les vérifications nil et la propagation idiomatique des erreurs. Établit le modèle mental qui régit toute la gestion des erreurs en Go.

Leçon 1 • Synchronisation avec le paquetage sync

Couvre Mutex, RWMutex, WaitGroup et Once pour la sécurité de l'état partagé. Complète la concurrence basée sur les canaux pour les scénarios nécessitant une mémoire partagée.

Leçon 2 • Goroutines et l'ordonnanceur Go

Explique la création de goroutines, l'ordonnanceur M:N et le cycle de vie des goroutines. Fournit le modèle conceptuel nécessaire pour raisonner sur l'exécution concurrente.

Leçon 3 • Patrons de concurrence courants

Démontre les pools de travailleurs, les pipelines et les architectures fan-out/fan-in. Les étudiants appliquent ces patrons pour construire des programmes concurrents évolutifs.

Leçon 4 • Instruction Select et multiplexage

Enseigne l'instruction select pour le multiplexage des opérations sur canaux. Permet les patrons de délai d'attente, d'annulation et de fan-in utilisés dans les services de production.

Leçon 1 • Auxiliaires de test et accessoires de test

Enseigne les fonctions auxiliaires, TestMain et la configuration de ressources temporaires. Réduit le code répétitif et améliore la lisibilité des tests dans les grandes suites de tests.

Leçon 2 • Benchmarks et profilage

Couvre les fonctions de benchmark, les boucles B.N et l'intégration pprof. Les étudiants identifient et éliminent les goulots d'étranglement de rendement avec des preuves fondées sur les données.

Leçon 3 • Écriture de tests unitaires avec le paquetage testing

Couvre les conventions de fichier de test, T.Error, T.Fatal et les sous-tests. Établit la discipline de test de base requise pour tous les projets Go.

Leçon 4 • Couverture de code et barrières de qualité

Explique les rapports de couverture, go test -cover et l'intégration de linter. Relie les tests aux pipelines d'intégration continue pour l'application automatisée de la qualité.