Home-theater-designers
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é.
UTILISEZ LA VIDÉO DU JOUR FAITES DÉFILER POUR CONTINUER AVEC LE CONTENU
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.
build: main.go utils.go
go build -o myapp main.go utils.go
clean:
rm myapp
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 .
des publicités s'affichent sur mon téléphone
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.
make build
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.
touch 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
# Variables
GOCMD=go
GOBUILD=$(GOCMD) build
GOTEST=$(GOCMD) test
GOCLEAN=$(GOCMD) clean
# Targets
build:
$(GOBUILD) -o app .
test:
$(GOTEST) ./...
clean:
$(GOCLEAN)
rm -f app
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
# Variables
GOCMD=go
GOBUILD=$(GOCMD) build
GOTEST=$(GOCMD) test
GOCLEAN=$(GOCMD) clean
BINARY_NAME=app
TEST_FLAGS=-v
# Targets
build:
$(GOBUILD) -o $(BINARY_NAME) .
test:
$(GOTEST) $(TEST_FLAGS) ./...
clean:
$(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 -dans 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
# Variables
GOCMD=go
GOBUILD=$(GOCMD) build
GOTEST=$(GOCMD) test
GOCLEAN=$(GOCMD) clean
BINARY_NAME=app
TEST_FLAGS=-v
GOOS=linux
GOARCH=amd64
# Targets
build:
$(GOBUILD) -o $(BINARY_NAME) .
test:
$(GOTEST) $(TEST_FLAGS) ./...
clean:
$(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 :
# Define variables
GOCMD = go
GOBUILD = $(GOCMD) build
BINARY_NAME = myprogram
# Default target
all: build
# Build target
build:
$(GOBUILD) -o $(BINARY_NAME)
# Clean target
clean:
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.
# Define variables
GOCMD = go
GOBUILD = $(GOCMD) build
GOGET = $(GOCMD) get
BINARY_NAME = myprogram
# Default target
all: build
# Build target
build:
$(GOBUILD) -o $(BINARY_NAME)
# Install dependencies
deps:
$(GOGET) -u
# Clean target
clean:
rm -f $(BINARY_NAME)
Le Makefile a un département 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 :
# Define variables
GODOC = godoc
DOCS_DIR = docs
# Default target
all: docs
# Generate documentation
docs:
$(GODOC) -html -dir . > $(DOCS_DIR)/index.html
# Clean target
clean:
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 fait 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.