Ce livre propose un apprentissage progressif du langage Go, langage conçu par Google pour allier performance, simplicité et gestion native de la concurrence dans le développement d’applications. Il s’adresse aux développeurs déjà familiers avec un langage comme Python, JavaScript, Java ou C, ainsi qu’aux apprenants et professionnels souhaitant élargir leurs compétences vers le développement backend, les microservices ou les outils systèmes.

L’ouvrage guide le lecteur depuis la découverte du langage jusqu’à la réalisation de projets concrets. Il présente d’abord les origines et la philosophie de Go, puis accompagne l’installation de l’environnement et la création d’un premier programme. Les chapitres suivants couvrent les bases du langage (types de données, variables, structures de contrôle, fonctions, tableaux et maps) avant d’aborder des notions avancées telles que struct, interfaces, pointeurs et gestion des erreurs.

Le développement web est ensuite exploré à travers la mise en place d’un serveur HTTP, la gestion des requêtes et réponses, la sérialisation JSON et l’utilisation de frameworks comme Gin ou Echo pour construire une API REST. Le livre traite également de la manipulation de fichiers, de l’accès aux bases de données relationnelles et de l’utilisation d’ORM tels que GORM. La gestion de la concurrence est expliquée avec les goroutines, les canaux et les mécanismes de synchronisation, illustrée par un serveur concurrent.

L’organisation et le test du code sont abordés avec les packages, la documentation, les tests unitaires, les benchmarks et le profiling. Plusieurs projets pratiques, comme un outil en ligne de commande, un serveur web ou un système d’automatisation, permettent de mettre en application les notions apprises. Le livre propose enfin une ouverture vers les microservices et l’intégration avec Docker pour approfondir ses compétences.

En combinant théorie, pratique et bonnes pratiques professionnelles, ce livre constitue à la fois un guide d’apprentissage et une référence durable pour tout développeur souhaitant maîtriser Go.

Caractéristiques

Livre (broché) - 17 x 21 cm
ISBN : 978-2-409-05295-8
EAN : 9782409052958
Ref. ENI : RIGOLANG

Caractéristiques

HTML
ISBN : 978-2-409-05296-5
EAN : 9782409052965
Ref. ENI : LNRIGOLANG

Avant-propos

Introduction
Objectifs du livre
À qui ce livre est-il destiné ?
Pourquoi apprendre Go ?
Progressivité de l’ouvrage

Introduction au langage Go

Origines et philosophie du langage
1. 1. Les origines de Go
  1. a. La genèse du projet
  2. b. Premières étapes du développement
  3. c. L’ouverture au public et l’évolutionde Go
2. 2. La philosophie du langage
  1. a. Simplicité et lisibilité
  2. b. Compilation rapide et efficacité
  3. c. Concurrence et performance
  4. d. Un langage pragmatique et productif
  5. e. Stabilité et compatibilité
  6. f. Un écosystème intégré etcohérent
  7. g. Une approche moderne du développement logiciel
3. 3. Un langage conçu pour l’efficacité
  1. a. Performance et rapidité d’exécution
  2. b. Gestion efficace de la mémoire
  3. c. Un modèle de concurrence efficace
  4. d. Compilation et déploiement rapides
  5. e. Simplicité du code et maintenance optimisée
  6. f. Adaptabilité aux architectures modernes
Pourquoi Go est-il un langage moderne ?
1. 1. Simplicité et minimalisme
2. 2. Performance et efficacité
3. 3. Conçu pour la concurrence
4. 4. Support natif du développement en réseau
5. 5. Stabilité et compatibilité
6. 6. Un écosystème en pleine croissance
Comparaison avec d’autres langages (C, Python, Java)
1. 1. Go vs C
  1. a. Gestion de la mémoire
  2. b. Sécurité et gestion des erreurs
  3. c. Concurrence et parallélisme
  4. d. Compilation et portabilité
  5. e. Simplicité et expressivité du langage
2. 2. Go vs Python
  1. a. Paradigme et philosophie
  2. b. Performance et gestion des ressources
  3. c. Concurrence et exécution parallèle
  4. d. Typage et sécurité du code
  5. e. Écosystème et cas d’utilisation
3. 3. Go vs Java
  1. a. Modèle d’exécution et performances
  2. b. Gestion de la mémoire et ramasse-miettes
  3. c. Concurrence et scalabilité
  4. d. Typage et structure du langage
  5. e. Écosystème et cas d’utilisation
Structure d’un programme Go
1. 1. Organisation du code
  1. a. Structuration des fichiers et répertoires
  2. b. Organisation des packages
  3. c. Séparation des responsabilités
  4. d. Gestion des dépendances et versionnage
  5. e. Respect des conventions et formatage automatique
2. 2. Gestion des packages
  1. a. Définition et rôle des packages
  2. b. Nomination et conventions des packages
  3. c. Importation et accessibilité des packages
  4. d. Packages standard et packages tiers
  5. e. Packages internes et encapsulation
  6. f. Optimisation de l’organisation des packages
Le compilateur et les outils intégrés
1. 1. Le compilateur Go
2. 2. Compilation d’un programme Go
  1. a. Principe de la compilation
  2. b. Compilation simple d’un programme
  3. c. Compilation multiplateforme
  4. d. Compilation avec optimisation
  5. e. Exécution et vérification de l’exécutable
  6. f. Gestion des erreurs de compilation
  7. g. Compilation en mode verbeux
3. 3. Les outils intégrés
  1. a. Outil de gestion des dépendances
  2. b. Outil de formatage du code
  3. c. Outil d’analyse statique
  4. d. Outil de test
  5. e. Outil de génération de documentation
  6. f. Outil de profilage et d’analyse des performances

Installation et premiers pas

Installation de Go sur votre système (Windows, macOS, Linux)
1. 1. Installation sur Windows
  1. a. Télécharger Go
  2. b. Installer Go
  3. c. Vérifier l’installation
2. 2. Installation sur macOS
  1. a. Télécharger et installer Go
  2. b. Vérifier l’installation
3. 3. Installation sur Linux
  1. a. Télécharger et extraire Go
  2. b. Configurer le chemin d’accès
  3. c. Vérifier l’installation
Configurer les variables d’environnement (GOPATH, GOROOT)
1. 1. Comprendre GOPATH et GOROOT
  1. a. GOROOT : le répertoire d’installationde Go
  2. b. GOPATH : l’espace de travail Go
  3. c. L’impact de GOROOT et GOPATH sur un projetGo
  4. d. Tester la configuration
2. 2. Configurer GOPATH et mettre à jour le PATH
  1. a. Définir GOPATH
  2. b. Ajouter GOPATH/bin au PATH
  3. c. Tester la configuration avec un programme Go
  4. d. Résolution des problèmes courants
3. 3. Vérifier la configuration
  1. a. Vérifier la version de Go
  2. b. Vérifier les variables d’environnement
  3. c. Tester la compilation d’un programme simple
  4. d. Tester l’installation d’un packageexterne
  5. e. Résolution des erreurs fréquentes
Votre premier programme avec go run
1. 1. Écrire un programme de base
  1. a. Structure d’un programme Go
  2. b. Exécuter le programme
  3. c. Compiler un exécutable
2. 2. Exécuter le programme avec Go run
  1. a. Comprendre go run
  2. b. Tester un programme avec Go run
  3. c. Exécution du programme
  4. d. Différence entre go run et go build
3. 3. Compilation et exécution indépendantes
  1. a. Compilation avec go build
  2. b. Vérification de l’exécutable
  3. c. Compilation multiplateforme
  4. d. Optimisation de la compilation
  5. e. Résolution des erreurs possibles
Structure d’un programme Go
1. 1. Initialiser un projet avec go mod
  1. a. Pourquoi utiliser go mod ?
  2. b. Création d’un projet avec go mod
  3. c. Ajouter des dépendances
  4. d. Mettre à jour et gérer les dépendances
  5. e. Vérifier les dépendances
  6. f. Résolution des erreurs courantes
2. 2. Ajouter et gérer des dépendances
  1. a. Détection implicite via l’importation depackages
  2. b. Ajout explicite d’une bibliothèquevia la commande go get
  3. c. Verrouillage de version
  4. d. Réaliser un audit minimal des dépendances
3. 3. Mettre à jour les dépendances
  1. a. Mettre à jour les dépendances avecla commande go get -u ./...
  2. b. Harmonisation des dépendances avec go modtidy
Introduction aux commandes Go (go build, go test, go fmt)
1. 1. Compilation avec go build
  1. a. Usage fondamental dans un projet local
  2. b. Compilation ciblée d’un fichiersource
  3. c. Bonnes pratiques liées à go build
2. 2. Test avec go test
  1. a. Conception d’un test basique
  2. b. Lancement des tests dans un projet
3. 3. Formatage avec go fmt
  1. a. Application du formatage sur un projet entier
  2. b. Intégration dans le flux de développement
  3. c. Limitations et compléments

Les bases du langage

Types de données fondamentaux : entiers, flottants, booléens, chaînes de caractères
1. 1. Types entiers
  1. a. Entiers signés
  2. b. Entiers non signés
2. 2. Types flottants
3. 3. Types booléens
4. 4. Chaînes de caractères
5. 5. Types spéciaux : byte et rune
6. 6. Valeurs zéro
7. 7. Conclusion sur les types de données fondamentaux
Variables, constantes et portée
1. 1. Déclaration de variables
  1. a. Déclaration explicite avec un type
  2. b. Déclaration et initialisation simultanées
  3. c. Déclaration de variables multiples
2. 2. Constantes
  1. a. Déclaration de constantes
  2. b. Constantes avec des types explicites
  3. c. Constantes de type iota
3. 3. Portée des variables
  1. a. Portée locale
  2. b. Portée globale
  3. c. Portée des variables avec :=
  4. d. Résumé des bonnes pratiques
4. 4. Conclusion sur les variables, constantes et la portée
Structures de contrôle : boucles (for), conditions (if, switch)
1. 1. La boucle for : l’unique boucle de Go
  1. a. La boucle for structurée : initialisation,condition, post-opération
  2. b. La boucle conditionnelle (équivalent implicitedu while)
  3. c. La boucle infinie contrôlée parbreak
  4. d. Utilisation de break et continue
2. 2. Les conditions if et else : exécution conditionnelle
  1. a. Condition simple avec if
  2. b. Bloc conditionnel if...else
  3. c. Chaînage conditionnel avec else if
  4. d. Initialisation locale dans la condition if
  5. e. Bonnes pratiques
3. 3. L’instruction switch : choix multiples
  1. a. Syntaxe de base du switch
  2. b. Forçage d’exécution avec fallthrough
  3. c. Gestion de plusieurs valeurs dans un mêmecase
  4. d. Le switch sans expression : comparaison conditionnelle
  5. e. Conseils pratiques pour l’usage de switch
Tableaux, slices et maps
1. 1. Tableaux (Arrays) : taille fixe et typée
  1. a. Déclaration et initialisation d’un tableau
  2. b. Accès et modification des éléments
  3. c. Longueur et itération
2. 2. Slices : flexibilité et dynamisme
  1. a. Définition et initialisation de slices
  2. b. Comprendre la longueur et la capacité
  3. c. Ajout d’éléments avec append()
  4. d. Copie sécurisée entre slices aveccopy()
3. 3. Maps : collections clé-valeur
  1. a. Déclaration et création d’une map
  2. b. Lecture et vérification des clés
  3. c. Modification ou ajout d’entrées
  4. d. Suppression d’éléments
  5. e. Parcours d’une map
Fonctions : syntaxe, paramètres, valeurs de retour
1. 1. Syntaxe de base d’une fonction
  1. a. Décomposition de la déclaration
  2. b. Fonctions sans paramètres ni valeurs de retour
  3. c. Importance de l’ordre des éléments
  4. d. Bonnes pratiques de définition
2. 2. Fonctions sans paramètres et sans valeursde retour
  1. a. Structure générale
  2. b. Utilisation dans un contexte plus large
  3. c. Avantages
3. 3. Fonctions avec paramètres
  1. a. Définir et utiliser des paramètres
  2. b. Simplification pour les types communs
  3. c. Fonctions avec plus de deux paramètres
  4. d. L’importance de l’ordre des paramètres
  5. e. Paramètres littéraux et variables
4. 4. Fonctions avec une seule valeur de retour
  1. a. Déclaration d’une fonction avec valeur deretour
  2. b. Utilisation directe du retour de fonction
  3. c. Remarques pratiques
5. 5. Fonctions avec plusieurs valeurs de retour
  1. a. Exemple : division sécurisée
  2. b. Ignorer certaines valeurs de retour
  3. c. Cas d’usage avancé : extraction de données
6. 6. Paramètres et valeurs de retour nommés
  1. a. Exemple de fonction arithmétique avec retoursnommés
  2. b. Intérêt des retours nommés
  3. c. Exemple avec valeurs numériques détaillées
  4. d. Précautions à prendre
7. 7. Fonctions variadiques
  1. a. Addition de plusieurs entiers
  2. b. Particularités et comportement
  3. c. Exemple avec plusieurs types de traitement

Les types complexes et la programmation structurée

Structures (struct) : définir vos propres types
1. 1. Déclaration d’une structure
  1. a. Définition et visibilité des structures
  2. b. Structures et types personnalisés
  3. c. Valeurs par défaut des structures
2. 2. Initialisation d’une structure
  1. a. Initialisation avec des valeurs explicites
  2. b. Allocation dynamique et pointeurs
  3. c. Initialisation avec une fonction constructeur
3. 3. Accès et modification des champs
  1. a. Accès aux champs
  2. b. Modification des champs
  3. c. Modification des champs via une fonction
  4. d. Vérification de la validité desdonnées avant modification
4. 4. Les structures par référence
Interfaces : concepts clés et polymorphisme
1. 1. Définition d’une interface
  1. a. Déclaration d’une interface
  2. b. Rôle des interfaces dans Go
  3. c. Interfaces avec plusieurs méthodes
  4. d. Utilisation d’une interface comme paramètrede fonction
2. 2. Implémentation d’une interface
  1. a. Implémentation implicite d’une interface
  2. b. Implémentation par plusieurs structures
  3. c. Vérification d’implémentationd’une interface
  4. d. Utilisation des interfaces dans les fonctions
3. 3. Utilisation du polymorphisme
  1. a. Passage d’une interface en paramètre
  2. b. Stockage de plusieurs types dans une collection
  3. c. Conversion de type avec assertion
4. 4. Interfaces vides et flexibilité
  1. a. Déclaration et utilisation d’uneinterface vide
  2. b. Passage d’une interface vide en paramètre
  3. c. Type assertion pour récupérer lavaleur d’une interface vide
  4. d. Type switch pour gérer plusieurs types dynamiquement
  5. e. Limites et bonnes pratiques
Pointeurs : comprendre les bases de la gestion mémoire
1. 1. Déclaration et utilisation des pointeurs
  1. a. Déclaration d’un pointeur
  2. b. Initialisation d’un pointeur
  3. c. Accès et modification via un pointeur
  4. d. Passage de pointeurs en argument de fonction
2. 2. Modification d’une variable via un pointeur
  1. a. Modification d’une variable à travers unpointeur
  2. b. Passage d’un pointeur en paramètre de fonction
  3. c. Utilisation des pointeurs pour échanger deuxvaleurs
3. 3. Pointeurs et structures
  1. a. Déclaration d’un pointeur vers une structure
  2. b. Modification des champs via un pointeur
  3. c. Passage d’une structure par pointeur à unefonction
  4. d. Allocation dynamique avec new
  5. e. Vérification d’un pointeur nil
4. 4. Les pointeurs nil
  1. a. Déclaration d’un pointeur nil
  2. b. Initialisation conditionnelle d’un pointeur
  3. c. Utilisation des pointeurs nil dans une structure
  4. d. Prévention des erreurs liées auxpointeurs nil
Gestion des erreurs : philosophie de Go et bonnes pratiques
1. 1. Principe de gestion des erreurs en Go
  1. a. Retour d’erreur avec le type error
  2. b. Vérification et traitement des erreurs
  3. c. Création d’erreurs personnalisées
  4. d. Ajout de contexte aux erreurs
2. 2. Vérification systématique des erreurs
  1. a. Vérification des erreurs après unappel de fonction
  2. b. Gestion des erreurs avec log.Fatal
  3. c. Renvoyer une erreur à l’appelant
  4. d. Utilisation des erreurs retournées dans uneboucle
3. 3. Création et manipulation des erreurs
  1. a. Création d’erreurs avec le package errors
  2. b. Ajout de contexte aux erreurs avec fmt.Errorf
  3. c. Comparaison des erreurs avec errors.Is
  4. d. Extraction d’informations avec errors.As
4. 4. Gestion avancée des erreurs avec errors.Iset errors.As
  1. a. Comparaison des erreurs avec errors.Is
  2. b. Extraction des erreurs avec errors.As
  3. c. Combinaison de errors.Is et errors.As
5. 5. Gestion des erreurs avec panic et recover
  1. a. Utilisation de panic
  2. b. Capture d’une panique avec recover
  3. c. Bonnes pratiques pour l’utilisation de panic et recover
6. 6. Bonnes pratiques pour la gestion des erreurs

Développement web avec Go

Créer un serveur HTTP simple avec le package net/http
1. 1. Mise en place d’un serveur HTTP minimal
  1. a. Définition de la structure du serveur
  2. b. Explications et bonnes pratiques
2. 2. Tester le serveur
  1. a. Démarrer le serveur
  2. b. Vérification avec un navigateur
  3. c. Tester avec curl
  4. d. Utilisation de Postman
  5. e. Écriture de tests automatisés
  6. f. Analyse des logs du serveur
3. 3. Ajouter des routes personnalisées
  1. a. Définition de plusieurs routes
  2. b. Tester les nouvelles routes
  3. c. Organisation des routes dans un routeur personnalisé
4. 4. Gestion des méthodes HTTP
  1. a. Différenciation des méthodes HTTP
  2. b. Tester les différentes méthodes
  3. c. Restriction d’accès à certainesméthodes
  4. d. Gestion avancée avec un routeur personnalisé
5. 5. Gestion des paramètres de requête
  1. a. Récupération des paramètresde requête
  2. b. Tester les paramètres de requête
  3. c. Récupération de plusieurs paramètres
  4. d. Validation des paramètres
  5. e. Utilisation des valeurs par défaut
Gérer les requêtes et les réponses
1. 1. Récupérer les informations d’unerequête HTTP
  1. a. Lire la méthode HTTP
  2. b. Lire les en-têtes de requête
  3. c. Lire les paramètres de l’URL
  4. d. Lire le corps de la requête
2. 2. Construire une réponse HTTP
  1. a. Envoyer une réponse simple
  2. b. Définir un statut HTTP personnalisé
  3. c. Ajouter des en-têtes HTTP
  4. d. Gérer les redirections HTTP
  5. e. Structurer une réponse JSON
Sérialisation des données avec JSON (encoding/json)
1. 1. Convertir une structure en JSON
  1. a. Sérialisation d’une structure simple
  2. b. Formatage du JSON pour la lisibilité
  3. c. Ignorer des champs lors de la conversion
  4. d. Gérer les erreurs de sérialisation
2. 2. Convertir un JSON en structure Go
  1. a. Désérialisation d’un JSONsimple
  2. b. Gérer des valeurs absentes ou nulles
  3. c. Désérialisation d’un tableauJSON
  4. d. Gérer les erreurs de conversion
3. 3. Sérialisation avec une liste de structures
  1. a. Sérialisation d’une liste de structures
  2. b. Formatage du JSON pour une meilleure lisibilité
  3. c. Gestion des valeurs vides
  4. d. Sérialisation et réponse HTTP
  5. e. Tester la sérialisation avec curl
4. 4. Gestion des erreurs lors de la conversion JSON
  1. a. Gestion des erreurs de sérialisation
  2. b. Gestion des erreurs de désérialisation
  3. c. Vérification des champs obligatoires
  4. d. Gérer les erreurs dans une API
5. 5. Exemple avancé : gestion des valeurs nulles
  1. a. Détection des valeurs nulles dans un JSON
  2. b. Utilisation des pointeurs pour gérer leschamps optionnels
  3. c. Sérialisation en excluant les valeurs nulles
  4. d. Gestion avancée avec sql.NullString
  5. e. Vérification et manipulation des valeursnulles
Frameworks populaires : Gin, Echo
1. 1. Gin : un framework performant et minimaliste
  1. a. Installation de Gin
  2. b. Création d’un serveur avec Gin
  3. c. Gestion des routes avec des paramètres
  4. d. Gestion des requêtes POST
  5. e. Middleware dans Gin
2. 2. Echo : un framework rapide et flexible
  1. a. Installation de Echo
  2. b. Création d’un serveur avec Echo
  3. c. Gestion des routes dynamiques
  4. d. Gestion des requêtes POST
  5. e. Middleware dans Echo
3. 3. Choisir entre Gin et Echo
Cas pratique : construire une API REST simple
1. 1. Installation et structure du projet
2. 2. Définition du modèle et des données
3. 3. Implémentation des routes CRUD
  1. a. Récupérer tous les articles
  2. b. Récupérer un article par son ID
  3. c. Ajouter un nouvel article
  4. d. Modifier un article existant
  5. e. Supprimer un article
4. 4. Mise en place du serveur et des routes
5. 5. Tester l’API avec curl

Gestion des fichiers et des bases de données

Lire et écrire dans des fichiers
1. 1. Lire un fichier
  1. a. Lire un fichier en entier
  2. b. Lire un fichier ligne par ligne
  3. c. Lire un fichier par blocs
  4. d. Lire un fichier avec un buffer personnalisé
2. 2. Écrire dans un fichier
  1. a. Écrire dans un fichier en remplaçantson contenu
  2. b. Ajouter du texte à un fichier existant
  3. c. Écrire ligne par ligne
  4. d. Écrire dans un fichier avec un buffer
Gestion des répertoires et manipulation des fichiers
1. 1. Créer un répertoire
  1. a. Créer un répertoire simple
  2. b. Créer un répertoire avec des sous-dossiers
  3. c. Vérifier si un répertoire existeavant de le créer
  4. d. Créer un répertoire avec des permissionsspécifiques
2. 2. Lister le contenu d’un répertoire
  1. a. Lister les noms des fichiers d’un répertoire
  2. b. Lister les fichiers avec leurs informations détaillées
  3. c. Lister uniquement les fichiers et exclure les répertoires
  4. d. Lister uniquement les répertoires
  5. e. Lister les fichiers d’un répertoireavec une extension spécifique
3. 3. Supprimer un fichier ou un répertoire
  1. a. Supprimer un fichier
  2. b. Supprimer un répertoire vide
  3. c. Supprimer un répertoire et son contenu
  4. d. Vérifier si un fichier ou un répertoireexiste avant suppression
  5. e. Supprimer plusieurs fichiers d’un répertoire
4. 4. Renommer ou déplacer un fichier
  1. a. Renommer un fichier
  2. b. Déplacer un fichier vers un autre répertoire
  3. c. Vérifier l’existence d’un fichier avant dele renommer ou le déplacer
  4. d. Gérer le déplacement entre différentssystèmes de fichiers
5. 5. Vérifier l’existence d’unfichier ou d’un répertoire
  1. a. Vérifier si un fichier existe
  2. b. Vérifier si un répertoire existe
  3. c. Différencier un fichier d’un répertoire
  4. d. Vérifier si un fichier est accessible enlecture et en écriture
  5. e. Vérifier l’existence de plusieursfichiers à la fois
Introduction aux bases de données relationnelles avec database/sql
1. 1. Installation d’un pilote SQL
  1. a. Installer un pilote SQL pour MySQL
  2. b. Installer un pilote SQL pour PostgreSQL
  3. c. Installer un pilote SQL pour SQLite
  4. d. Vérifier l’installation du pilote
  5. e. Résolution des erreurs courantes
2. 2. Connexion à une base de données
  1. a. Établir une connexion à une basede données MySQL
  2. b. Connexion à une base de donnéesPostgreSQL
  3. c. Connexion à une base de donnéesSQLite
  4. d. Gestion des erreurs de connexion
  5. e. Gérer une connexion avec un pool de connexions
3. 3. Exécuter des requêtes SQL
  1. a. Exécuter une requête SQL pour créerune table
  2. b. Insérer des données dans une table
  3. c. Lire des données d’une table
  4. d. Mettre à jour des données
  5. e. Supprimer un enregistrement
  6. f. Gérer les erreurs et les transactions
Utilisation d’un ORM comme GORM
1. 1. Pourquoi utiliser GORM ?
2. 2. Installation de GORM
  1. a. Installer GORM et un pilote de base de données
  2. b. Vérifier l’installation de GORM
  3. c. Vérification de la configuration des dépendances
  4. d. Détection et correction des erreurs courantes
3. 3. Connexion à une base de données
  1. a. Connexion à une base de donnéesMySQL avec GORM
  2. b. Connexion à une base de donnéesPostgreSQL
  3. c. Connexion à une base de donnéesSQLite
  4. d. Gestion des erreurs de connexion
  5. e. Configuration du pool de connexions
4. 4. Définition des modèles
  1. a. Définir un modèle simple
  2. b. Ajout d’options avancées aux modèles
  3. c. Définir des relations entre les modèles
  4. d. Automatiser la création des tables avec GORM
5. 5. Migration automatique des tables
  1. a. Utiliser AutoMigrate pour créer les tables
  2. b. Ajouter de nouvelles colonnes avec AutoMigrate
  3. c. Attention aux limitations de AutoMigrate
  4. d. Exécuter des migrations SQL personnalisées
6. 6. Opérations CRUD avec GORM
  1. a. Création d’un enregistrement (Create)
  2. b. Lecture des enregistrements (Read)
  3. c. Mise à jour d’un enregistrement(Update)
  4. d. Suppression d’un enregistrement (Delete)
  5. e. Gestion avancée des transactions
7. 7. Gestion des relations avec GORM
  1. a. Relation One-to-One (Un à Un)
  2. b. Relation One-to-Many (Un à Plusieurs)
  3. c. Relation Many-to-Many (Plusieurs à Plusieurs)
  4. d. Charger les relations avec GORM
  5. e. Gestion avancée des relations
8. 8. Avantages et limites de GORM
  1. a. Avantages
  2. b. Inconvénients

Concurrence et parallélisme

Introduction à la concurrence en Go
1. 1. Pourquoi la concurrence est-elle importante ?
2. 2. Les goroutines
3. 3. Synchronisation avec les channels
4. 4. Utilisation de sync.WaitGroup
Les goroutines : exécution parallèle simplifiée
1. 1. Qu’est-ce qu’une goroutine ?
2. 2. Lancer une goroutine
  1. a. Création et exécution d’une goroutine
  2. b. Explication du comportement
  3. c. Gestion des goroutines multiples
  4. d. Points clés à retenir
  5. e. Comparaison avec un appel synchrone
  6. f. Cas d’utilisation des goroutines
3. 3. Lancer plusieurs goroutines
  1. a. Exécution concurrente de plusieurs goroutines
  2. b. Explication du comportement
  3. c. Passage d’arguments dans une goroutine
  4. d. Pourquoi passer les arguments de manièreexplicite ?
  5. e. Synchronisation des goroutines multiples
  6. f. Points clés à retenir
4. 4. Synchronisation des goroutines
  1. a. Introduction à sync.WaitGroup
  2. b. Utilisation des channels pour la synchronisation
  3. c. Utilisation de sync.Mutex pour protéger lesdonnées partagées
  4. d. Quand utiliser quel mécanisme ?
Communication entre Goroutines avec les canaux (channels)
1. 1. Création et utilisation de base d’un channel
2. 2. Utilisation des channels bufferisés
3. 3. Fermeture d’un channel
4. 4. Synchronisation avec un channel de signalisation
5. 5. Utilisation des channels pour coordonner plusieursgoroutines
6. 6. Comparaison entre différents mécanismesde synchronisation
Synchronisation des données partagées
1. 1. Problèmes liés aux accèsconcurrents
2. 2. Utilisation des mutex (sync.Mutex)
  1. a. Principe de fonctionnement d’un mutex
  2. b. Exemple d’utilisation d’un mutex
  3. c. Risques liés à l’utilisation desmutex
  4. d. Alternative : utilisation de sync.RWMutex
  5. e. Bonnes pratiques d’utilisation des mutex
3. 3. Utilisation des opérations atomiques
  1. a. Introduction aux opérations atomiques
  2. b. Exemple d’incrémentation atomique
  3. c. Comparaison entre mutex et opérations atomiques
  4. d. Chargement et stockage atomique
  5. e. Opérations de comparaison et d’échange
  6. f. Quand utiliser les opérations atomiques ?
4. 4. Utilisation des channels pour la synchronisation
  1. a. Synchronisation simple avec un channel
  2. b. Utilisation d’un channel pour coordonner plusieursgoroutines
  3. c. Fermeture d’un channel pour signaler la findes opérations
  4. d. Comparaison entre channels et autres mécanismesde synchronisation
Cas pratique : construire un serveur concurrent
1. 1. Mise en place d’un serveur HTTP simple
2. 2. Amélioration avec un pool de travailleurs
3. 3. Gestion des délais et des erreurs
4. 4. Optimisation avec un serveur HTTP concurrent efficace
5. 5. Résumé des bonnes pratiques

Structurer et tester son code

Organisation d’un projet Go : packages, modules et dépendances
1. 1. Structure d’un projet Go
  1. a. Organisation des fichiers et répertoires
  2. b. Rôle des répertoires
  3. c. Séparation du code applicatif et des bibliothèques
  4. d. Gestion des exécutables
2. 2. Modules en Go
  1. a. Définition et rôle des modules
  2. b. Initialisation d’un module
  3. c. Gestion des dépendances
  4. d. Mise à jour et suppression des dépendances
  5. e. Versionnement des modules
  6. f. Remplacement de modules locaux
  7. g. Exportation d’un module
3. 3. Organisation des packages
  1. a. Définition et structuration des packages
  2. b. Importation et utilisation des packages
  3. c. Packages internes et encapsulation
  4. d. Organisation recommandée des packages
  5. e. Gestion des dépendances entre packages
  6. f. Meilleures pratiques pour organiser les packages
4. 4. Gestion des dépendances
  1. a. Introduction aux dépendances
  2. b. Ajouter une nouvelle dépendance
  3. c. Fixer une version spécifique
  4. d. Supprimer des dépendances inutilisées
  5. e. Vérifier l’intégrité desdépendances
  6. f. Remplacer une dépendance locale
  7. g. Désactiver la gestion des modules
  8. h. Meilleures pratiques pour la gestion des dépendances
Documentation de code avec godoc
1. 1. Écrire des commentaires compatibles avecgodoc
  1. a. Principes de base des commentaires
  2. b. Commenter un package
  3. c. Commenter une fonction
  4. d. Commenter une structure et ses champs
  5. e. Commenter une méthode
  6. f. Commenter des constantes et des variables globales
  7. g. Exemples d’utilisation pour la documentation
  8. h. Meilleures pratiques pour la documentation
2. 2. Générer et afficher la documentation
  1. a. Installation et configuration de godoc
  2. b. Démarrer un serveur de documentation local
  3. c. Afficher la documentation d’un package spécifique
  4. d. Ajouter des descriptions détaillées
  5. e. Générer la documentation d’unprojet privé
  6. f. Exporter la documentation pour un partage externe
  7. g. Meilleures pratiques pour l’affichage dela documentation
3. 3. Documentation des structures et méthodes
  1. a. Documentation des structures imbriquées
  2. b. Afficher la documentation spécifique d’unestructure ou méthode
  3. c. Meilleures pratiques pour la documentation des structureset méthodes
Introduction aux tests unitaires avec testing
1. 1. Pourquoi écrire des tests unitaires ?
2. 2. Structure d’un test en Go
  1. a. Organisation des fichiers de test
  2. b. Définition d’un test unitaire
  3. c. Utilisation de t.Errorf pour afficher les erreurs
  4. d. Exécution des tests
  5. e. Affiche un rapport des tests réussis ou échoués
  6. f. Organisation des tests avec t.Run
  7. g. Meilleures pratiques pour écrire des testsunitaires
3. 3. Exécuter les tests
  1. a. Exécuter les tests d’un packagespécifique
  2. b. Exécution détaillée avecl’option -v
  3. c. Exécuter un test précis
  4. d. Désactiver la mise en cache des tests
  5. e. Exécuter les tests avec des variables d’environnement
  6. f. Intégration des tests dans un pipeline CI/CD
  7. g. Meilleures pratiques pour l’exécutiondes tests
4. 4. Utiliser t.Run() pour organiser plusieurs cas de test
  1. a. Pourquoi utiliser t.Run() ?
  2. b. Exemple simple d’utilisation de t.Run()
  3. c. Structurer les tests avec une boucle
  4. d. Exécution ciblée d’un sous-test
  5. e. Exécution parallèle des sous-tests
  6. f. Meilleures pratiques pour l’utilisation det.Run()
Benchmarks et optimisation des performances
1. 1. Qu’est-ce qu’un benchmark ?
2. 2. Écrire un benchmark en Go
  1. a. Structure d’un benchmark
  2. b. Comparer plusieurs implémentations
  3. c. Benchmark avec allocation mémoire
  4. d. Exécuter un benchmark avec différentestailles d’entrée
  5. e. Optimisation après benchmark
3. 3. Exécuter un benchmark
  1. a. Commande de base pour exécuter un benchmark
  2. b. Exécuter un benchmark spécifique
  3. c. Afficher des résultats détaillés
  4. d. Exécuter un benchmark avec une duréespécifique
  5. e. Comparer plusieurs exécutions avec -count
  6. f. Désactiver la mise en cache des benchmarks
  7. g. Utiliser pprof pour un profilage avancé
  8. h. Meilleures pratiques pour l’exécutiondes benchmarks
Debugging et profiling avec pprof
1. 1. Activer pprof dans un serveur Go
  1. a. Ajouter pprof à un serveur HTTP
  2. b. Accéder aux endpoints de pprof
  3. c. Capturer un profil CPU via la ligne de commande
  4. d. Analyser l’utilisation mémoire
  5. e. Afficher un profil en mode interactif
  6. f. Protéger l’accès aux profils
  7. g. Meilleures pratiques pour l’utilisation depprof
2. 2. Capturer un profil CPU
  1. a. Capturer un profil CPU en mode serveur
  2. b. Analyser un profil CPU avec pprof
  3. c. Capturer un profil CPU dans un programme Go
  4. d. Visualiser un profil CPU en mode graphique
  5. e. Identifier les fonctions lentes
  6. f. Comparer plusieurs profils CPU
  7. g. Meilleures pratiques pour l’analyse CPU
3. 3. Profiling mémoire
  1. a. Capturer un profil mémoire via un serveurHTTP
  2. b. Analyser un profil mémoire avec pprof
  3. c. Capturer un profil mémoire dans un programme
  4. d. Identifier les fuites de mémoire
  5. e. Comparer plusieurs captures mémoire
  6. f. Visualiser le profil mémoire avec une interfacegraphique
  7. g. Meilleures pratiques pour l’analyse mémoire
4. 4. Visualisation avec pprof
  1. a. Générer un profil d’exécution
  2. b. Lancer l’interface graphique de pprof
  3. c. Afficher un graphe des performances
  4. d. Explorer les statistiques dans l’interfaceweb
  5. e. Générer un Flame Graph
  6. f. Comparer plusieurs profils
  7. g. Meilleures pratiques pour la visualisation avec pprof

Projets pratiques

Créer un outil en ligne de commande (CLI)
1. 1. Création d’un CLI simple
  1. a. Initialisation du projet CLI
  2. b. Implémentation d’un CLI de base
  3. c. Analyse du code
  4. d. Exécution du programme
2. 2. Utilisation de cobra pour un CLI avancé
  1. a. Installation de Cobra et initialisation du projet
  2. b. Structure du projet
  3. c. Implémentation d’une commande personnalisée
  4. d. Exécution du CLI
  5. e. Ajout d’options à une commande
3. 3. Ajout de commandes personnalisées
  1. a. Ajout d’une commande personnalisée time
  2. b. Exécution de la nouvelle commande
  3. c. Ajout d’options à une commande personnalisée
  4. d. Exécution avec des options
  5. e. Documentation et aide
Utilisation du package flag
1. 1. Introduction au package flag
2. 2. Déclaration et utilisation des flags
  1. a. Définition de flags de base
  2. b. Exécution avec différents arguments
  3. c. Gestion des flags obligatoires
  4. d. Récupération des arguments non traités
3. 3. Flags booléens et autres types
  1. a. Flags booléens
  2. b. Flags numériques
  3. c. Flags de type durée
4. 4. Gestion des arguments non flag
  1. a. Récupération des arguments non flag
  2. b. Vérification du nombre d’argumentsnon flag
  3. c. Traitement des arguments non flag comme fichiers
Cas pratique : automatiser une tâche répétitive
1. 1. Objectif du projet
2. 2. Structure du projet
  1. a. Organisation des fichiers
  2. b. Rôle des principaux fichiers
3. 3. Implémentation du programme
  1. a. Initialisation du projet
  2. b. Définition des paramètres configurables
  3. c. Réalisation de la vérification web
  4. d. Implémentation du système de tentatives
  5. e. Enregistrement des logs
  6. f. Exécution en boucle
  7. g. Test du programme
4. 4. Améliorations possibles
Développer une application web
1. 1. Initialisation du projet
2. 2. Mise en place du serveur HTTP
  1. a. Définition des routes principales
  2. b. Gestion des erreurs HTTP
  3. c. Utilisation des middlewares pour le logging
  4. d. Configuration d’un serveur avec timeout
3. 3. Gestion des routes et rendu des templates
  1. a. Définition des gestionnaires de routes
  2. b. Rendu dynamique avec des templates
  3. c. Chargement efficace des templates
4. 4. Ajout d’une page dynamique avec formulaire
  1. a. Ajout d’une route pour le formulaire
  2. b. Conception du formulaire HTML
  3. c. Validation des entrées utilisateur
  4. d. Redirection et confirmation
  5. e. Gestion des erreurs et affichage des messages
5. 5. Exécution et tests
Construire un serveur web avec gestion des requêtes
1. 1. Initialisation du projet
2. 2. Mise en place du serveur HTTP
3. 3. Gestion des requêtes GET et POST
  1. a. Traitement des requêtes GET
  2. b. Traitement des requêtes POST
4. 4. Ajout de middlewares
5. 5. Tests et exécution du serveur
Ajouter des tests et déployer
1. 1. Ajouter des tests unitaires
  1. a. Structure des tests dans un projet
  2. b. Écrire un premier test unitaire
  3. c. Exécution des tests
  4. d. Tester un gestionnaire HTTP
  5. e. Utilisation de t.Run pour structurer plusieurs casde test
2. 2. Déploiement de l’application
  1. a. Compilation et optimisation du binaire
  2. b. Transfert du binaire vers le serveur distant
  3. c. Exécution en arrière-plan avec systemd
  4. d. Conteneurisation avec Docker
  5. e. Surveillance et journaux
  6. f. Mises à jour et redéploiement

Aller plus loin avec Go

Go pour les microservices
1. 1. Pourquoi utiliser Go pour les microservices ?
2. 2. Mise en place du microservice
  1. a. Préparation de l’environnement
  2. b. Organisation des fichiers
  3. c. Mise en place des dépendances
  4. d. Définition des routes
  5. e. Lancer le serveur
3. 3. Développement du microservice
  1. a. Implémentation des gestionnaires de requêtes
  2. b. Séparation de la logique métier
  3. c. Ajout d’une nouvelle ressource
  4. d. Lancer et tester le microservice
Déployer une application Go avec Docker
1. 1. Pourquoi utiliser Docker pour Go ?
2. 2. Étape 1 : création d’une applicationGo simple
  1. a. Initialisation du projet
  2. b. Création du fichier principal
  3. c. Compilation et exécution
  4. d. Ajout d’une interaction utilisateur
  5. e. Organisation en modules
  6. f. Test et validation
3. 3. Étape 2 : création du Dockerfile
  1. a. Choix de l’image de base
  2. b. Configuration du répertoire de travail
  3. c. Copie des fichiers et gestion des dépendances
  4. d. Compilation de l’application
  5. e. Optimisation de l’image Docker
  6. f. Validation du Dockerfile
4. 4. Étape 3 : construire et exécuterle conteneur
  1. a. Génération de l’image Docker
  2. b. Lancement du conteneur
  3. c. Inspection et suivi du conteneur
  4. d. Gestion du cycle de vie du conteneur
  5. e. Nettoyage des ressources Docker
5. 5. Étape 4 : déploiement sur un serveurdistant
  1. a. Définition des variables d’environnementdans Docker
  2. b. Lecture des variables d’environnement dansGo
  3. c. Validation des variables d’environnement
  4. d. Sécurisation des variables d’environnement
  5. e. Suppression des variables après exécution
Outils avancés pour les développeurs Go
1. 1. Gestion des dépendances avec go mod
  1. a. Initialisation d’un module Go
  2. b. Ajout et gestion des dépendances
  3. c. Gestion des versions des dépendances
  4. d. Vérification et correction des dépendances
  5. e. Utilisation des vendored dependencies
  6. f. Bonnes pratiques pour la gestion des dépendances
2. 2. Analyse statique du code
  1. a. Présentation des outils d’analysestatique
  2. b. Utilisation de go vet
  3. c. Vérification du style avec golint
  4. d. Détection des erreurs avec staticcheck
  5. e. Optimisation du formatage avec gofmt et goimports
  6. f. Intégration dans un workflow de CI/CD
  7. g. Bonnes pratiques pour une analyse efficace
3. 3. Tests et couverture de code
  1. a. Organisation des tests
  2. b. Approfondissement des assertions et cas limites
  3. c. Exécution et analyse des tests
  4. d. Mesure de la couverture du code
  5. e. Mocks et tests unitaires avancés
  6. f. Tests de performance
4. 4. Profilage et optimisation avec pprof
  1. a. Activation de pprof dans une application
  2. b. Analyse des profils CPU
  3. c. Profilage de l’utilisation mémoire
  4. d. Visualisation avec pprof et go tool
  5. e. Optimisation basée sur les résultatsde profilage
  6. f. Automatisation du profilage en production
5. 5. Compilation et distribution
  1. a. Compilation multiplateforme
  2. b. Optimisation du binaire
  3. c. Inclusion des ressources statiques
  4. d. Signature et validation de l’exécutable
  5. e. Automatisation du processus de distribution
Ressources et communauté pour continuer à apprendre
1. 1. Documentation officielle
2. 2. Cours et tutoriels en ligne
3. 3. Communauté et forums
4. 4. Projets open-source et contributions
5. 5. Conférences et événements

24/03/2026Version papier

Très bon livre.

pierre c

Louis LAUGIER

Louis LAUGIER est développeur freelance, spécialisé dans la conception d’applications web et d’outils logiciels. Passionné par les langages modernes et les environnements performants, il accompagne ses clients dans la réalisation de solutions robustes, évolutives et maintenables. Fort d’une expérience variée en développement et animé par un réel intérêt pour la pédagogie, il a rédigé cet ouvrage afin de proposer une approche claire et progressive de la maîtrise du langage Go.

Golang Les fondamentaux du langage de Google

Informations

Informations

Caractéristiques

Caractéristiques

Louis LAUGIER

Nos nouveautés