Comment rationaliser votre développement Go avec les Makefiles

Dans le développement de logiciels modernes, une automatisation efficace de la construction est cruciale pour la réussite d'un projet. Makefiles, un outil d'automatisation de construction populaire, offre aux développeurs de toutes les piles un moyen concis et puissant de gérer des processus de construction complexes.

En intégrant et en interopérant Makefiles avec Go, vous pouvez automatiser les tâches répétitives, rationaliser les processus de construction et améliorer la productivité.

Comprendre les Makefiles

Comprendre le fonctionnement des Makefiles est crucial pour organiser et automatiser efficacement les builds de votre projet.

Les makefiles suivent une structure et une syntaxe spécifiques pour définir les règles de construction et de maintenance des projets. À la base, un Makefile se compose de règles spécifiant les cibles, les dépendances et les commandes. Chaque règle commence par une cible, suivie de ses dépendances et des commandes nécessaires pour créer ou exécuter la cible.

Les cibles représentent les fichiers de sortie souhaités ou les actions pour le Makefile. Les cibles peuvent être des noms de fichiers ou des étiquettes qui décrivent la tâche. Par exemple, une cible nommée faire le ménage peut supprimer les fichiers inutiles générés pendant le processus de construction.

Les dépendances sont des fichiers ou des tâches nécessaires à la création d'une cible. Si des dépendances sont modifiées, le Makefile reconstruira les cibles associées pour s'assurer que les parties nécessaires du projet fonctionnent. Vous spécifierez les dépendances après la cible, séparées par des espaces.

Les commandes sont des actions ou commandes shell qui nécessitent une exécution pour créer ou exécuter des cibles spécifiques. Les commandes sont généralement écrites dans un langage de script shell du système d'exploitation.

Chaque commande doit commencer par un caractère de tabulation pour être reconnue.

construction: main.go utils.go
 go build -o myapp main.go utils.go
faire le ménage:
 rm mon application

Dans le Makefile ci-dessus, il y a deux cibles: construire et faire le ménage.

Le construire la cible dépend de la main.go et utils.go fichiers, et la commande associée s'exécute sur le compilateur Go pour créer un exécutable nommé monapp.

D'autre part, le faire le ménage cible supprime le monapp exécutable.

Pour compiler votre code Go, accédez au répertoire de travail et exécutez le faire construire commande.

faire construire

L'outil Make gérera le processus de compilation, vous permettant de vous concentrer sur l'écriture de code.

Configuration de Makefiles pour vos projets Go

Vous pouvez utiliser Makefiles pour créer et compiler vos programmes, effectuer des tests de code et des contrôles de qualité, ainsi que pour une intégration et un déploiement continus.

Exécutez cette commande pour créer un Makefile pour votre projet dans le répertoire racine. Le Makefile servira de point d'entrée pour définir vos tâches de construction.

toucher Makefile

Votre Makefile ne devrait pas avoir d'extensions.

Après avoir créé le Makefile, vous pouvez écrire des commandes, des dépendances et des cibles dans le fichier pour les opérations de votre projet.

Voici un exemple de Makefile qui sert d'outil d'automatisation de build pour votre projet :

# Makefile
#Variable
GOCMD=aller
CONSTRUIRE=$(GOCMD) construire
GOTEST=$(GOCMD) test
GOCLEAN=$(GOCMD) faire le ménage
# Cibles
construire:
$(GOBUILD) -o application .
test:
$(GOTEST) ./...
faire le ménage:
$(GOCLEAN)
 rm -f application

Vous pouvez personnaliser votre Makefile en fonction des besoins spécifiques de votre projet.

Voici une version modifiée du Makefile pour transmettre des drapeaux supplémentaires et des variables d'environnement pendant le processus de test ou de construction de votre projet :

# Makefile
#Variable
GOCMD=aller
CONSTRUIRE=$(GOCMD) construire
GOTEST=$(GOCMD) test
GOCLEAN=$(GOCMD) faire le ménage
BINARY_NAME=application
TEST_FLAGS=-v
# Cibles
construire:
$(GOBUILD) -o $(BINARY_NAME) .
test:
$(GOTEST)$(TEST_FLAGS) ./...
faire le ménage:
$(GOCLEAN)
 rm-f $(BINARY_NAME)

Dans ce Makefile, il y a deux nouvelles variables nommées BINARY_NAME et TEST_FLAGS. Le BINARY_NAME La variable spécifie le nom du fichier exécutable généré.

Le TEST_FLAGS vous permet de spécifier des indicateurs supplémentaires lors de l'exécution de tests (dans ce cas, la -v active une sortie détaillée pendant l'exécution du test).

Makefiles fournit également un moyen simple de configurer des variables d'environnement et des drapeaux pour votre projet.

Vous pouvez ajouter ces lignes à votre Makefile si vous avez besoin de définir le GOOS et GOARCH variables pour construire votre projet pour un système d'exploitation ou une architecture spécifique.

# Makefile
#Variable
GOCMD=aller
CONSTRUIRE=$(GOCMD) construire
GOTEST=$(GOCMD) test
GOCLEAN=$(GOCMD) faire le ménage
BINARY_NAME=application
TEST_FLAGS=-v
GOOS=linux
GOARCH=amd64
# Cibles
construire:
$(GOBUILD) -o $(BINARY_NAME) .
test:
$(GOTEST)$(TEST_FLAGS) ./...
faire le ménage:
$(GOCLEAN)
 rm-f $(BINARY_NAME)

Dans le Makefile mis à jour, il y a deux nouvelles variables pour le GOOS et GOARCH variables d'environnement qui vous permettent de spécifier le système d'exploitation cible et l'architecture de votre build (dans ce cas, le GOOS variable est définie sur linux et GOARCH pour AMD64 pour construire le projet pour Linux sur l'architecture x86-64).

N'oubliez pas d'adapter ces variables en fonction des exigences spécifiques de votre projet.

Vous pouvez vous référer au Accéder à la documentation pour la liste des valeurs prises en charge pour GOOS et GOARCH si vous avez besoin de construire pour une plate-forme différente.

Construire l'automatisation avec les Makefiles

Les makefiles sont également pratiques pour compiler du code, générer de la documentation et gérer les dépendances.

Avec Makefiles, vous pouvez automatiser le temps de compilation, ce qui vous fait gagner du temps et des efforts.

Voici un Makefile qui compile un programme Go :

# Définir les variables
GOCMD = aller
CONSTRUIRE = $(GOCMD) construire
BINARY_NAME = monprogramme
# Cible par défaut
tout: construire
# Cible de construction
construire:
$(GOBUILD) -o $(BINARY_NAME)
# Nettoyer la cible
faire le ménage:
 rm-f $(BINARY_NAME)

Le Makefile définit des variables comme le GOCMD (la commande Go) et CONSTRUIRE (la commande de construction). Le construire la cible appelle le allez construire commande pour compiler notre programme Go et produire le binaire avec le nom spécifié (monprogramme dans ce cas). Le faire le ménage target supprime le binaire généré du projet.

Vous pouvez utiliser Makefiles pour automatiser l'installation des dépendances et maintenir à jour les dépendances externes de votre projet.

# Définir les variables
GOCMD = aller
CONSTRUIRE = $(GOCMD) construire
GOGET = $(GOCMD) obtenir
BINARY_NAME = monprogramme
# Cible par défaut
tout: construire
# Cible de construction
construire:
$(GOBUILD) -o $(BINARY_NAME)
# Installer les dépendances
en profondeur :
$(GOGET) -u
# Nettoyer la cible
faire le ménage:
 rm-f $(BINARY_NAME)

Le Makefile a un des profondeurs cible qui utilise le va chercher commande pour installer ou mettre à jour les dépendances du projet. Tu peux courir faire des dépôts pour installer les dépendances de votre projet.

Les makefiles peuvent automatiser la génération de documentation et améliorer votre docs en tant que processus de code.

Voici comment vous pouvez générez automatiquement la documentation de vos projets Go avec l'outil godoc et Makefile :

# Définir les variables
GODOC = godoc
DOCS_DIR = docs
# Cible par défaut
tout: docs
# Générer de la documentation
documents :
$(GODOC) -html -rép. > $(DOCS_DIR)/index.html
# Nettoyer la cible
faire le ménage:
 rm-rf $(DOCS_DIR)

Dans le Makefile, le documents la cible appelle le godoc commande avec le -html flag pour générer une documentation HTML pour votre code go et enregistre la documentation dans le documents annuaire.

Vous exécuterez le faire des docs pour générer une documentation à jour pour votre projet Go.

Les makefiles sont pratiques pour travailler avec des systèmes d'exploitation basés sur Unix

En tirant parti de la flexibilité des Makefiles, vous pouvez définir des commandes de construction personnalisées et exécuter des tâches complexes en quelques minutes. Makefile permet de gagner du temps et assure la cohérence et la reproductibilité dans tous les environnements de construction.

Un autre avantage des Makefiles est sa compatibilité avec les systèmes basés sur Unix. Make est un utilitaire largement pris en charge sur les systèmes d'exploitation basés sur Unix, y compris Linux et macOS, ce qui en fait un outil portable et fiable pour les développeurs.