Formation pour apprendre le langage Go

Leçon 1 • Variables, types et constantes

Présente le typage statique, l'inférence de type et les déclarations de constantes. Ancre les étudiants dans le système de type strict de Go avant l'apparition des structures de données complexes.

Leçon 2 • Opérateurs et expressions

Couvre les opérateurs arithmétiques, de comparaison, logiques et binaires. Prépare les étudiants à écrire une logique conditionnelle et de calcul significative.

Leçon 3 • Syntaxe de base et structure du programme

Couvre les paquets, les importations, la fonction main et la syntaxe des instructions. Fournit le squelette structurel pour tous les programmes Go écrits dans ce cours.

Leçon 4 • Structures de contrôle de flux

Enseigne les instructions if, for, switch et defer comme la boîte à outils de contrôle complète de Go. Permet aux étudiants d'écrire des programmes avec une logique de branchement et d'itération.

Leçon 1 • Récursivité et valeurs de fonction

Explore les algorithmes récursifs et les fonctions en tant que valeurs de première classe. Prépare les étudiants aux patrons d'ordre supérieur et aux conceptions basées sur les callbacks.

Leçon 2 • Panique, rétablissement et patrons defer

Couvre la propagation de panique, les mécanismes de rétablissement et le nettoyage basé sur defer. Équipe les étudiants pour gérer les défaillances inattendues sans faire planter les services de production.

Leçon 3 • Fonctions variadiques et fermetures

Présente les paramètres variadiques et les littéraux de fonction qui capturent la portée. Permet des API flexibles et des patrons de programmation fonctionnelle en Go.

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

Couvre les signatures de fonction, les paramètres et les valeurs de retour. Établit l'unité de code réutilisable sur laquelle toutes les abstractions ultérieures sont construites.

Leçon 1 • Patrons de tranche et pièges

Aborde la sémantique de copie, les tableaux de support partagés et les bogues courants. Prévient les problèmes de mémoire et d'exactitude qui surviennent dans le code réel utilisant intensivement les tranches.

Leçon 2 • Structures et balises de structure

Présente la déclaration de structure, l'accès aux champs, l'imbrication et les balises. Fournit la base de type personnalisé pour la modélisation de domaine et la sérialisation.

Leçon 3 • Tableaux et tranches

Distingue les tableaux fixes des tranches dynamiques et couvre les aspects internes des tranches. Fournit le type de collection de travail utilisé dans pratiquement tous les programmes Go.

Leçon 4 • Cartes

Couvre la création de maps, les opérations CRUD et la sémantique d'itération. Permet la modélisation de données clé-valeur essentielle pour la configuration, la mise en cache et les tables de correspondance.

Leçon 1 • Méthodes sur les types

Enseigne les récepteurs de valeur et de pointeur, les expressions de méthode et la promotion. Relie les définitions de structure aux contrats comportementaux exprimés via les interfaces.

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

Couvre les assertions de type sûres et non sûres ainsi que la construction switch de type. Permet l'inspection de type à l'exécution nécessaire pour les patrons de répartition de style générique.

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

Couvre la déclaration d'interface, la satisfaction implicite et les ensembles de méthodes. Établit le mécanisme de polymorphisme central à la conception idiomatique en Go.

Leçon 4 • Composition d'interfaces et patrons de conception

Explore la composition de petites interfaces et l'application de l'injection de dépendances. Produit des architectures logicielles faiblement couplées et testables.

Leçon 1 • Documentation et génération de code

Enseigne les conventions godoc, les fonctions d'exemple et go generate. Produit des paquets auto-documentés et automatise les tâches de code répétitives.

Leçon 2 • Outils de linting et de qualité du code

Présente staticcheck, golangci-lint et l'application du formatage. Intègre les normes de qualité professionnelle dans chaque projet dès le premier jour.

Leçon 3 • Principes d'organisation des paquets

Couvre les conventions de nommage, les identifiants exportés et les paquets internes. Établit la discipline structurelle qui maintient la navigabilité des grandes bases de code.

Leçon 4 • Commandes de construction, de test et d'analyse

Couvre go build, go test, go vet et les balises de construction. Intègre les contrôles de qualité dans le flux de travail de développement dès le début.

Leçon 1 • Instruction select et délais d'attente

Enseigne l'instruction select pour le multiplexage des opérations sur les canaux. Permet les patrons d'E/S non bloquants et les flux de travail concurrents contrôlés par délai d'attente.

Leçon 2 • Primitives de synchronisation : Mutex et WaitGroup

Présente sync.Mutex, sync.RWMutex et sync.WaitGroup pour l'état partagé. Complète la conception basée sur les canaux avec des outils de synchronisation de bas niveau.

Leçon 3 • 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 4 • Détection de course et patrons de concurrence

Utilise le détecteur de course et couvre les pipelines, le fan-out et les pools de workers. Produit des architectures concurrentes vérifiées et de qualité production.

Leçon 1 • Primitives d'E/S et opérations sur les fichiers

Couvre les paquets io, bufio et os pour la lecture et l'écriture de données. Fournit la base d'E/S pour le traitement de fichiers et les programmes basés sur les flux.

Leçon 2 • Bases du client et du serveur HTTP

Présente net/http pour la création de serveurs et l'envoi de requêtes HTTP. Fournit la base réseau développée dans le chapitre appliqué à venir.

Leçon 3 • Chaînes, octets et Unicode

Enseigne les paquets strings, bytes, unicode et strconv pour le traitement de texte. Permet une manipulation correcte des données UTF-8 dans les applications internationales.

Leçon 4 • Heure, dates et minuteries

Explore le paquet time pour l'analyse, le formatage et la planification. Permet une logique sensible au temps dans les API, les tâches et les systèmes orientés événements.

Leçon 1 • Tests unitaires avec le paquet testing

Couvre les fonctions de test, les tests pilotés par tableau et les sous-tests. Établit la discipline de test de base appliquée à chaque paquet du cours.

Leçon 2 • Tests d'intégration et de bout en bout

Couvre httptest, les bases de données en mémoire et les conteneurs de test. Valide le comportement du système à travers les limites des composants dans des conditions réalistes.

Leçon 3 • Benchmarking et profilage

Utilise les fonctions de benchmark, pprof et trace pour trouver les goulots d'étranglement. Produit des améliorations de performance basées sur les données et fondées sur la mesure.

Leçon 4 • Techniques et outils de débogage

Couvre le débogueur Delve, le traçage basé sur les logs et les diagnostics d'exécution. Équipe les étudiants pour localiser et corriger efficacement les défauts dans n'importe quel programme Go.