Gör ditt liv enklare genom att automatisera repetitiva uppgifter med Makefiles.
I modern mjukvaruutveckling är effektiv byggautomatisering avgörande för ett projekts framgång. Makefiles, ett populärt verktyg för byggautomatisering, ger utvecklare av alla stackar ett kortfattat och kraftfullt sätt att hantera komplexa byggprocesser.
Genom att integrera och interoperera Makefiles med Go kan du automatisera repetitiva uppgifter, effektivisera byggprocesser och förbättra produktiviteten.
Förstå Makefiles
Att förstå hur Makefiles fungerar är avgörande för att effektivt organisera och automatisera dina projektbyggen.
Makefiler följer en specifik struktur och syntax för att definiera regler för att bygga och underhålla projekt. Kärnan består en Makefil av regler som anger mål, beroenden och kommandon. Varje regel börjar med ett mål, följt av dess beroenden och de kommandon som behövs för att bygga eller exekvera målet.
Mål representerar önskade utdatafiler eller åtgärder för Makefilen. Mål kan vara filnamn eller etiketter som beskriver uppgiften. Till exempel ett mål som heter
rena kan ta bort onödiga filer som genererats under byggprocessen.Beroenden är filer eller uppgifter som krävs för att bygga ett mål. Om några beroenden ändras kommer Makefilen att bygga om associerade mål för att säkerställa att nödvändiga delar av projektet fungerar. Du anger beroenden efter målet, avgränsade med mellanslag.
Kommandon är åtgärder eller skalkommandon som behöver utföras för att bygga eller utföra specifika mål. Kommandon skrivs vanligtvis i ett skalskriptspråk i operativsystemet.
Varje kommando måste börja med ett tabbtecken för igenkänning.
build: main.go utils.go
gå bygga -o myapp main.go utils.go
rena:
rm minapp
I ovanstående Makefile finns det två mål: bygga och rena.
De bygga målet beror på main.go och utils.go filer, och det associerade kommandot körs på Go-kompilatorn för att bygga en körbar med namnet minapp.
Å andra sidan rena målet tar bort minapp körbar.
För att kompilera din Go-kod, navigera till arbetskatalogen och kör göra bygga kommando.
göra bygga
Verktyget Make kommer att hantera kompileringsprocessen, så att du kan fokusera på att skriva kod.
Konfigurera Makefiler för dina Go-projekt
Du kan använda Makefiles för att bygga och kompilera dina program, utföra kodtester och kvalitetskontroller och för kontinuerlig integration och distribution.
Kör det här kommandot för att skapa en Makefile för ditt projekt i rotkatalogen. De Makefile kommer att fungera som startpunkten för att definiera dina bygguppgifter.
tryck på Makefile
Din Makefile bör inte ha några tillägg.
Efter att ha skapat Makefilen kan du skriva kommandon, beroenden och mål till filen för ditt projekts verksamhet.
Här är ett exempel på Makefile som fungerar som ett byggautomatiseringsverktyg för ditt projekt:
# Makefile# Variabler
GOCMD=gå
GOBUILD=$(GOCMD) bygga
GÖTESTA=$(GOCMD) testa
GOCLEAN=$(GOCMD) rena# Mål
bygga:
$(GOBUILD) -o app.testa:
$(GOTEST) ./...
rena:
$(GOCLEAN)
rm -f app
Du kan anpassa din Makefile efter ditt projekts specifika behov.
Här är en modifierad version av Makefile för att skicka ytterligare flaggor och miljövariabler under ditt projekts test- eller byggprocess:
# Makefile# Variabler
GOCMD=gå
GOBUILD=$(GOCMD) bygga
GÖTESTA=$(GOCMD) testa
GOCLEAN=$(GOCMD) rena
BINARY_NAME=app
TEST_FLAGS=-v# Mål
bygga:
$(GOBUILD) -o $(BINARY_NAME) .testa:
$(GOTEST)$(TEST_FLAGS) ./...
rena:
$(GOCLEAN)
rm -f $(BINARY_NAME)
I den här Makefilen finns två nya variabler namngivna BINARY_NAME och TEST_FLAGS. De BINARY_NAME variabel anger namnet på den genererade körbara filen.
De TEST_FLAGS variabeln låter dig ange ytterligare flaggor när du kör tester (i det här fallet -v flaggan möjliggör utförlig utdata under testkörning).
Makefiles ger också ett enkelt sätt att konfigurera miljövariabler och flaggor för ditt projekt.
Du kan lägga till dessa rader i din Makefile om du behöver ställa in GÅS och GOARCH variabler för att bygga ditt projekt för ett specifikt operativsystem eller arkitektur.
# Makefile# Variabler
GOCMD=gå
GOBUILD=$(GOCMD) bygga
GÖTESTA=$(GOCMD) testa
GOCLEAN=$(GOCMD) rena
BINARY_NAME=app
TEST_FLAGS=-v
GOOS=linux
GOARCH=amd64# Mål
bygga:
$(GOBUILD) -o $(BINARY_NAME) .testa:
$(GOTEST)$(TEST_FLAGS) ./...
rena:
$(GOCLEAN)
rm -f $(BINARY_NAME)
I den uppdaterade Makefile finns det två nya variabler för GÅS och GOARCH miljövariabler som låter dig specificera måloperativsystemet och arkitekturen för din byggnad (i det här fallet GÅS variabeln är inställd på linux och GOARCH till amd64 att bygga projektet för Linux på x86-64-arkitekturen).
Kom ihåg att anpassa dessa variabler baserat på ditt projekts specifika krav.
Du kan hänvisa till Gå dokumentation för listan över värden som stöds för GÅS och GOARCH om du behöver bygga för en annan plattform.
Bygg automation med Makefiler
Makefiler är också praktiska för att kompilera kod, generera dokumentation och hantera beroenden.
Med Makefiles kan du automatisera kompileringstid, vilket sparar tid och ansträngning.
Här är en Makefile som kompilerar ett Go-program:
# Definiera variabler
GOCMD = gå
GOBUILD = $(GOCMD) bygga
BINARY_NAME = mitt program# Standardmål
alla: bygga# Bygg mål
bygga:
$(GOBUILD) -o $(BINARY_NAME)
# Rent mål
rena:
rm -f $(BINARY_NAME)
Makefilen definierar variabler som GOCMD (kommandot Gå) och GOBILD (byggkommandot). De bygga mål åberopar gå bygg kommando för att kompilera vårt Go-program och producera binären med det angivna namnet (mitt program I detta fall). De rena target tar bort den genererade binära filen från projektet.
Du kan använda Makefiles för att automatisera beroendeinstallationen och hålla ditt projekts externa beroenden uppdaterade.
# Definiera variabler
GOCMD = gå
GOBUILD = $(GOCMD) bygga
GOGET = $(GOCMD) skaffa sig
BINARY_NAME = mitt program# Standardmål
alla: bygga# Bygg mål
bygga:
$(GOBUILD) -o $(BINARY_NAME)# Installationsberoenden
deps:
$(GOGET) -u
# Rent mål
rena:
rm -f $(BINARY_NAME)
Makefilen har en deps mål som använder att få kommando för att installera eller uppdatera projektberoende. Du kan springa göra deps för att installera ditt projekts beroenden.
Makefiles kan automatisera dokumentationsgenerering och förbättra din docs som kodprocess.
Så här kan du generera automatiskt dokumentation för dina Go-projekt med godoc-verktyget och Makefile:
# Definiera variabler
GODOC = godok
DOCS_DIR = docs# Standardmål
alla: docs# Skapa dokumentation
docs:
$(GODOC) -html -dir. > $(DOCS_DIR)/index.html
# Rent mål
rena:
rm -rf $(DOCS_DIR)
I Makefilen, den docs mål åberopar godoc kommandot med -html flagga för att generera HTML-dokumentation för din go-kod och sparar dokumentationen till docs katalog.
Du kommer att köra göra dokument kommando för att generera uppdaterad dokumentation för ditt Go-projekt.
Makefiler är praktiska för att arbeta med Unix-baserade operativsystem
Genom att utnyttja flexibiliteten hos Makefiles kan du definiera anpassade byggkommandon och utföra komplexa uppgifter inom några minuter. Makefile sparar tid och säkerställer konsekvens och reproducerbarhet över byggmiljöer.
En annan fördel med Makefiles är dess kompatibilitet med Unix-baserade system. Make är ett brett stödd verktyg på Unix-baserade operativsystem, inklusive Linux och macOS, vilket gör det till ett bärbart och pålitligt verktyg för utvecklare.
