Sådan strømliner du din Go-udvikling med Makefiles

I moderne softwareudvikling er effektiv byggeautomatisering afgørende for et projekts succes. Makefiles, et populært byggeautomatiseringsværktøj, giver udviklere af alle stakke en kortfattet og kraftfuld måde at styre komplekse byggeprocesser på.

Ved at integrere og interoperere Makefiles med Go kan du automatisere gentagne opgaver, strømline byggeprocesser og øge produktiviteten.

Forståelse af Makefiles

At forstå, hvordan Makefiles fungerer, er afgørende for effektivt at organisere og automatisere dine projektopbygninger.

Makefiler følger en specifik struktur og syntaks til at definere regler for opbygning og vedligeholdelse af projekter. Kernen består en Makefil af regler, der specificerer mål, afhængigheder og kommandoer. Hver regel begynder med et mål, efterfulgt af dets afhængigheder og de nødvendige kommandoer for at bygge eller udføre målet.

Mål repræsenterer de ønskede outputfiler eller handlinger for Makefilen. Mål kan være filnavne eller etiketter, der beskriver opgaven. For eksempel et mål med navn

ren kan fjerne unødvendige filer, der er genereret under byggeprocessen.

Afhængigheder er filer eller opgaver, der kræves for at opbygge et mål. Hvis nogen afhængigheder ændres, vil Makefilen genopbygge tilknyttede mål for at sikre, at nødvendige dele af projektet fungerer. Du angiver afhængigheder efter målet, adskilt af mellemrum.

Kommandoer er handlinger eller skal kommandoer der skal udføres for at opbygge eller udføre specifikke mål. Kommandoer er normalt skrevet i et shell-scriptsprog i operativsystemet.

Hver kommando skal begynde med et tabulatortegn for genkendelse.

build: main.go utils.go
 go build -o myapp main.go utils.go
ren:
 rm minapp

I ovenstående Makefile er der to mål: bygge og ren.

Det bygge målet afhænger af main.go og utils.go filer, og den tilknyttede kommando kører på Go-kompileren for at bygge en eksekverbar med navnet min app.

På den anden side ren målet fjerner min app eksekverbar.

For at kompilere din Go-kode skal du navigere til arbejdsbiblioteket og køre lave bygge kommando.

lave bygge

Make-værktøjet håndterer kompileringsprocessen, så du kan fokusere på at skrive kode.

Opsætning af Makefiles til dine Go-projekter

Du kan bruge Makefiles til at bygge og kompilere dine programmer, udføre kodetest og kvalitetstjek og til kontinuerlig integration og implementering.

Kør denne kommando for at oprette en Makefile til dit projekt i rodmappen. Det Makefile vil fungere som indgangspunktet for at definere dine byggeopgaver.

tryk på Makefil

Din Makefile bør ikke have nogen udvidelser.

Efter oprettelse af Makefilen kan du skrive kommandoer, afhængigheder og mål til filen for dit projekts operationer.

Her er et eksempel på Makefile, der fungerer som et byggeautomatiseringsværktøj til dit projekt:

# Makefil
# Variabler
GOCMD=gå
GOBUILD=$(GOCMD) bygge
GÅETT=$(GOCMD) prøve
GOCLEAN=$(GOCMD) ren
# Mål
bygge:
$(GOBUILD) -o app.
prøve:
$(GOTEST) ./...
ren:
$(GOCLEAN)
 rm -f app

Du kan tilpasse din Makefile efter dit projekts specifikke behov.

Her er en ændret version af Makefilen til at sende yderligere flag og miljøvariabler under dit projekts test- eller byggeproces:

# Makefil
# Variabler
GOCMD=gå
GOBUILD=$(GOCMD) bygge
GÅETT=$(GOCMD) prøve
GOCLEAN=$(GOCMD) ren
BINARY_NAME=app
TEST_FLAGS=-v
# Mål
bygge:
$(GOBUILD) -o $(BINARY_NAME) .
prøve:
$(GOTEST)$(TEST_FLAGS) ./...
ren:
$(GOCLEAN)
 rm -f $(BINARY_NAME)

I denne Makefile er der navngivet to nye variabler BINARY_NAME og TEST_FLAGS. Det BINARY_NAME variabel angiver navnet på den genererede eksekverbare fil.

Det TEST_FLAGS variabel giver dig mulighed for at angive yderligere flag, når du kører test (i dette tilfælde -v flag aktiverer detaljeret output under testudførelse).

Makefiles giver også en nem måde at konfigurere miljøvariabler og flag for dit projekt.

Du kan tilføje disse linjer til din Makefile, hvis du har brug for at indstille GOOS og GOARCH variabler til at bygge dit projekt til et specifikt operativsystem eller arkitektur.

# Makefil
# Variabler
GOCMD=gå
GOBUILD=$(GOCMD) bygge
GÅETT=$(GOCMD) prøve
GOCLEAN=$(GOCMD) ren
BINARY_NAME=app
TEST_FLAGS=-v
GOOS=linux
GOARCH=amd64
# Mål
bygge:
$(GOBUILD) -o $(BINARY_NAME) .
prøve:
$(GOTEST)$(TEST_FLAGS) ./...
ren:
$(GOCLEAN)
 rm -f $(BINARY_NAME)

I den opdaterede Makefile er der to nye variabler for GOOS og GOARCH miljøvariabler, der giver dig mulighed for at specificere måloperativsystemet og arkitekturen for din build (i dette tilfælde GOOS variabel er sat til linux og GOARCH til amd64 at bygge projektet til Linux på x86-64-arkitekturen).

Husk at tilpasse disse variabler baseret på dit projekts specifikke krav.

Du kan henvise til Gå til dokumentation for listen over understøttede værdier for GOOS og GOARCH hvis du skal bygge til en anden platform.

Byg automatisering med Makefiles

Makefiler er også praktiske til at kompilere kode, generere dokumentation og administrere afhængigheder.

Med Makefiles kan du automatisere kompileringstid, hvilket sparer dig tid og kræfter.

Her er en Makefile, der kompilerer et Go-program:

# Definer variabler
GOCMD = gå
GOBUILD = $(GOCMD) bygge
BINARY_NAME = mit program
# Standardmål
alle: bygge
# Byg mål
bygge:
$(GOBUILD) -o $(BINARY_NAME)
# Ren mål
ren:
 rm -f $(BINARY_NAME)

Makefilen definerer variabler som GOCMD (Gå-kommandoen) og GOBUILD (byggekommandoen). Det bygge målet påberåber sig gå bygge kommando til at kompilere vores Go-program og producere det binære med det angivne navn (mit program I dette tilfælde). Det ren target fjerner den genererede binære fil fra projektet.

Du kan bruge Makefiles til at automatisere afhængighedsinstallation og holde dit projekts eksterne afhængigheder opdateret.

# Definer variabler
GOCMD = gå
GOBUILD = $(GOCMD) bygge
GOGET = $(GOCMD) få
BINARY_NAME = mit program
# Standardmål
alle: bygge
# Byg mål
bygge:
$(GOBUILD) -o $(BINARY_NAME)
# Installer afhængigheder
deps:
$(GOGET) -u
# Ren mål
ren:
 rm -f $(BINARY_NAME)

Makefilen har en deps mål, der bruger Hent kommando til at installere eller opdatere projektafhængigheder. Du kan løbe lave deps for at installere dit projekts afhængigheder.

Makefiles kan automatisere dokumentationsgenerering og forbedre din docs som kodeproces.

Sådan kan du autogenerer dokumentation til dine Go-projekter med godoc-værktøjet og Makefile:

# Definer variabler
GODOC = godok
DOCS_DIR = dokumenter
# Standardmål
alle: docs
# Generer dokumentation
dokumenter:
$(GODOC) -html -dir. > $(DOCS_DIR)/index.html
# Ren mål
ren:
 rm -rf $(DOCS_DIR)

I Makefilen er dokumenter målet påberåber sig godoc kommando med -html flag for at generere HTML-dokumentation til din go-kode og gemmer dokumentationen til dokumenter vejviser.

Du vil køre lave dokumenter kommando til at generere opdateret dokumentation for dit Go-projekt.

Makefiler er praktiske til at arbejde med Unix-baserede operativsystemer

Ved at udnytte fleksibiliteten i Makefiles kan du definere brugerdefinerede build-kommandoer og udføre komplekse opgaver inden for få minutter. Makefile sparer tid og sikrer konsistens og reproducerbarhed på tværs af byggemiljøer.

En anden fordel ved Makefiles er dens kompatibilitet med Unix-baserede systemer. Make er et bredt understøttet værktøj på Unix-baserede operativsystemer, herunder Linux og macOS, hvilket gør det til et bærbart og pålideligt værktøj for udviklere.