Maak uw leven gemakkelijker door repetitieve taken te automatiseren met Makefiles.
Bij moderne softwareontwikkeling is efficiënte bouwautomatisering cruciaal voor het succes van een project. Makefiles, een populaire tool voor het automatiseren van builds, biedt ontwikkelaars van alle stacks een beknopte en krachtige manier om complexe buildprocessen te beheren.
Door Makefiles te integreren en te laten samenwerken met Go, kunt u repetitieve taken automatiseren, bouwprocessen stroomlijnen en de productiviteit verhogen.
Makefiles begrijpen
Begrijpen hoe Makefiles werken is cruciaal voor het efficiënt organiseren en automatiseren van uw projectbuilds.
Makefiles volgen een specifieke structuur en syntaxis voor het definiëren van regels voor het bouwen en onderhouden van projecten. In de kern bestaat een Makefile uit regels die doelen, afhankelijkheden en opdrachten specificeren. Elke regel begint met een doel, gevolgd door de bijbehorende afhankelijkheden en de opdrachten die nodig zijn om het doel te bouwen of uit te voeren.
Doelen vertegenwoordigen de gewenste uitvoerbestanden of acties voor de Makefile. Doelen kunnen bestandsnamen zijn of labels die de taak beschrijven. Bijvoorbeeld een doelwit met de naam schoon kan onnodige bestanden verwijderen die tijdens het bouwproces zijn gegenereerd.
Afhankelijkheden zijn bestanden of taken die nodig zijn voor het bouwen van een doel. Als er afhankelijkheden worden gewijzigd, zal de Makefile de bijbehorende doelen opnieuw opbouwen om ervoor te zorgen dat de noodzakelijke onderdelen van het project functioneren. U specificeert afhankelijkheden na het doel, gescheiden door spaties.
Commando's zijn acties of shell-commando's die moeten worden uitgevoerd om specifieke doelen te bouwen of uit te voeren. Opdrachten worden meestal geschreven in een shell-scripttaal van het besturingssysteem.
Elke opdracht moet beginnen met een tabteken voor herkenning.
bouwen: main.go utils.go
ga bouwen -o mijnapp main.go utils.go
schoon:
rm mijnapp
In de bovenstaande Makefile zijn er twee doelen: bouwen En schoon.
De bouwen doel hangt af van de hoofd.go En utils.go bestanden en de bijbehorende opdracht wordt uitgevoerd op de Go-compiler om een uitvoerbaar bestand met de naam mijnapp.
Aan de andere kant, de schoon doelwit verwijdert de mijnapp uitvoerbaar.
Om uw Go-code te compileren, navigeert u naar de werkmap en voert u het bouwen maken commando.
bouwen maken
De Make-tool zorgt voor het compilatieproces, zodat u zich kunt concentreren op het schrijven van code.
Makefiles instellen voor uw Go-projecten
U kunt Makefiles gebruiken om uw programma's te bouwen en te compileren, codetests en kwaliteitscontroles uit te voeren en voor continue integratie en implementatie.
Voer deze opdracht uit om een Makefile voor uw project in de hoofdmap te maken. De Makefile zal dienen als het startpunt voor het definiëren van uw bouwtaken.
tik op Makefile
Uw Makefile mag geen extensies hebben.
Nadat u de Makefile hebt gemaakt, kunt u opdrachten, afhankelijkheden en doelen naar het bestand schrijven voor de bewerkingen van uw project.
Hier is een voorbeeld van Makefile dat dient als een automatiseringstool voor het bouwen van uw project:
# Makefile# Variabelen
GOCMD=gaan
GOBOUW=$(GOCMD) bouwen
GETEST=$(GOCMD) test
GOCLEAN=$(GOCMD) schoon# Doelen
bouwen:
$(GOBOUW) -o app.test:
$(GETEST) ./...
schoon:
$(GOCLEAN)
rm -f app
U kunt uw Makefile aanpassen aan de specifieke behoeften van uw project.
Hier is een aangepaste versie van de Makefile voor het doorgeven van extra vlaggen en omgevingsvariabelen tijdens het test- of bouwproces van uw project:
# Makefile# Variabelen
GOCMD=gaan
GOBOUW=$(GOCMD) bouwen
GETEST=$(GOCMD) test
GOCLEAN=$(GOCMD) schoon
BINARY_NAME=app
TEST_FLAGS=-v# Doelen
bouwen:
$(GOBOUW) -O $(BINARY_NAME) .test:
$(GETEST)$(TEST_FLAGS) ./...
schoon:
$(GOCLEAN)
rm-f $(BINARY_NAME)
In deze Makefile zijn er twee nieuwe variabelen genoemd BINARY_NAME En TEST_FLAGS. De BINARY_NAME variabele specificeert de naam van het gegenereerde uitvoerbare bestand.
De TEST_FLAGS variabele stelt u in staat extra vlaggen te specificeren bij het uitvoeren van tests (in dit geval de -v vlag maakt uitgebreide uitvoer mogelijk tijdens testuitvoering).
Makefiles biedt ook een gemakkelijke manier om omgevingsvariabelen en vlaggen voor uw project te configureren.
U kunt deze regels aan uw Makefile toevoegen als u de GOOS En GOARCH variabelen om uw project te bouwen voor een specifiek besturingssysteem of architectuur.
# Makefile# Variabelen
GOCMD=gaan
GOBOUW=$(GOCMD) bouwen
GETEST=$(GOCMD) test
GOCLEAN=$(GOCMD) schoon
BINARY_NAME=app
TEST_FLAGS=-v
GOOS=linux
GOARCH=amd64# Doelen
bouwen:
$(GOBOUW) -O $(BINARY_NAME) .test:
$(GETEST)$(TEST_FLAGS) ./...
schoon:
$(GOCLEAN)
rm-f $(BINARY_NAME)
In de bijgewerkte Makefile zijn er twee nieuwe variabelen voor de GOOS En GOARCH omgevingsvariabelen waarmee u het doelbesturingssysteem en de doelarchitectuur voor uw build kunt specificeren (in dit geval de GOOS variabele is ingesteld op linux En GOARCH naar amd64 om het project voor Linux op de x86-64-architectuur te bouwen).
Vergeet niet om deze variabelen aan te passen op basis van de specifieke vereisten van uw project.
U kunt verwijzen naar de Ga documentatie voor de lijst met ondersteunde waarden voor GOOS En GOARCH als u voor een ander platform moet bouwen.
Bouw automatisering met Makefiles
Makefiles zijn ook handig voor het compileren van code, het genereren van documentatie en het beheren van afhankelijkheden.
Met Makefiles kunt u de compilatietijd automatiseren, waardoor u tijd en moeite bespaart.
Hier is een Makefile die een Go-programma compileert:
# Definieer variabelen
GOCMD = gaan
GOBUILD = $(GOCMD) bouwen
BINARY_NAME = mijnprogramma# Standaard doel
alles: bouwen# Bouw doel
bouwen:
$(GOBOUW) -O $(BINARY_NAME)
# Schoon doelwit
schoon:
rm-f $(BINARY_NAME)
De Makefile definieert variabelen zoals de GOCMD (het Go-commando) en GOBOUW (het build-commando). De bouwen doel beroept zich op de ga bouwen opdracht om ons Go-programma te compileren en het binaire bestand met de opgegeven naam (mijnprogramma in dit geval). De schoon target verwijdert het gegenereerde binaire bestand uit het project.
U kunt Makefiles gebruiken om de installatie van afhankelijkheden te automatiseren en de externe afhankelijkheden van uw project up-to-date te houden.
# Definieer variabelen
GOCMD = gaan
GOBUILD = $(GOCMD) bouwen
GOGET = $(GOCMD) krijgen
BINARY_NAME = mijnprogramma# Standaard doel
alles: bouwen# Bouw doel
bouwen:
$(GOBOUW) -O $(BINARY_NAME)# Installeer afhankelijkheden
afdelingen:
$(GOGET) -u
# Schoon doelwit
schoon:
rm-f $(BINARY_NAME)
De Makefile heeft een deps doel dat gebruik maakt van de ga halen opdracht om projectafhankelijkheden te installeren of bij te werken. Je kan lopen dep maken om de afhankelijkheden van uw project te installeren.
Makefiles kan het genereren van documentatie automatiseren en uw docs als codeproces.
Hier is hoe je kunt automatisch documentatie genereren voor uw Go-projecten met de godoc-tool en Makefile:
# Definieer variabelen
GODOC = godoc
DOCS_DIR = documenten# Standaard doel
alles: documenten# Documentatie genereren
documenten:
$(GODOC) -html -dir. > $(DOCS_DIR)/index.html
# Schoon doelwit
schoon:
rm-rf $(DOCS_DIR)
In de Makefile, de documenten doel beroept zich op de goed commando met de -html flag om HTML-documentatie voor uw go-code te genereren en slaat de documentatie op in het documenten map.
Je voert de documenten maken opdracht om up-to-date documentatie voor uw Go-project te genereren.
Makefiles zijn handig voor het werken met op Unix gebaseerde besturingssystemen
Door gebruik te maken van de flexibiliteit van Makefiles, kunt u binnen enkele minuten aangepaste bouwopdrachten definiëren en complexe taken uitvoeren. Makefile bespaart tijd en zorgt voor consistentie en reproduceerbaarheid in alle gebouwde omgevingen.
Een ander voordeel van Makefiles is de compatibiliteit met op Unix gebaseerde systemen. Make is een breed ondersteund hulpprogramma op Unix-gebaseerde besturingssystemen, waaronder Linux en macOS, waardoor het een draagbare en betrouwbare tool is voor ontwikkelaars.
