Slik effektiviserer du Go-utviklingen din med Makefiles

I moderne programvareutvikling er effektiv byggeautomatisering avgjørende for et prosjekts suksess. Makefiles, et populært byggeautomatiseringsverktøy, gir utviklere av alle stabler en kortfattet og kraftig måte å administrere komplekse byggeprosesser på.

Ved å integrere og interoperere Makefiles med Go kan du automatisere repeterende oppgaver, strømlinjeforme byggeprosesser og øke produktiviteten.

Forstå Makefiles

Å forstå hvordan Makefiles fungerer er avgjørende for å effektivt organisere og automatisere prosjektbyggene dine.

Makefiles følger en spesifikk struktur og syntaks for å definere regler for bygging og vedlikehold av prosjekter. I kjernen består en Makefil av regler som spesifiserer mål, avhengigheter og kommandoer. Hver regel begynner med et mål, etterfulgt av dets avhengigheter og kommandoene som trengs for å bygge eller utføre målet.

Mål representerer de ønskede utdatafilene eller handlingene for Makefilen. Mål kan være filnavn eller etiketter som beskriver oppgaven. For eksempel et mål som heter

ren kan fjerne unødvendige filer generert under byggeprosessen.

Avhengigheter er filer eller oppgaver som kreves for å bygge et mål. Hvis noen avhengigheter endres, vil Makefilen gjenoppbygge tilknyttede mål for å sikre at nødvendige deler av prosjektet fungerer. Du spesifiserer avhengigheter etter målet, atskilt med mellomrom.

Kommandoer er handlinger eller shell-kommandoer som trenger utførelse for å bygge eller utføre spesifikke mål. Kommandoer er vanligvis skrevet i et shell-skriptspråk i operativsystemet.

Hver kommando må begynne med et tabulatortegn for gjenkjenning.

bygge: main.go utils.go
 gå bygge -o myapp main.go utils.go
ren:
 rm minapp

I Makefilen ovenfor er det to mål: bygge og ren.

De bygge målet avhenger av main.go og utils.go filer, og den tilhørende kommandoen kjører på Go-kompilatoren for å bygge en kjørbar med navnet minapp.

På den annen side ren målet fjerner minapp kjørbar.

For å kompilere Go-koden din, naviger til arbeidskatalogen og kjør lage bygge kommando.

lage bygge

Make-verktøyet vil håndtere kompileringsprosessen, slik at du kan fokusere på å skrive kode.

Sette opp Makefiles for Go-prosjektene dine

Du kan bruke Makefiles til å bygge og kompilere programmene dine, utføre kodetester og kvalitetskontroller og for kontinuerlig integrasjon og distribusjon.

Kjør denne kommandoen for å lage en Makefile for prosjektet ditt i rotkatalogen. De Makefile vil tjene som inngangspunkt for å definere byggeoppgavene dine.

trykk på Lag fil

Makefilen din skal ikke ha noen utvidelser.

Etter å ha opprettet Makefilen, kan du skrive kommandoer, avhengigheter og mål til filen for prosjektets operasjoner.

Her er et eksempel på Makefile som fungerer som et byggeautomatiseringsverktøy for prosjektet ditt:

# Makefile
# Variabler
GOCMD=gå
GOBUILD=$(GOCMD) bygge
FÅTT=$(GOCMD) test
GOCLEAN=$(GOCMD) ren
# Mål
bygge:
$(GOBUILD) -o app.
test:
$(GOTEST) ./...
ren:
$(GOCLEAN)
 rm -f app

Du kan tilpasse Makefile i henhold til prosjektets spesifikke behov.

Her er en modifisert versjon av Makefile for å sende flere flagg og miljøvariabler under prosjektets test- eller byggeprosess:

# Makefile
# Variabler
GOCMD=gå
GOBUILD=$(GOCMD) bygge
FÅTT=$(GOCMD) test
GOCLEAN=$(GOCMD) ren
BINARY_NAME=app
TEST_FLAGS=-v
# Mål
bygge:
$(GOBUILD) -o $(BINARY_NAME) .
test:
$(GOTEST)$(TEST_FLAGS) ./...
ren:
$(GOCLEAN)
 rm -f $(BINARY_NAME)

I denne Makefilen er det navngitt to nye variabler BINARY_NAME og TEST_FLAGS. De BINARY_NAME variabel angir navnet på den genererte kjørbare filen.

De TEST_FLAGS variabel lar deg spesifisere flere flagg når du kjører tester (i dette tilfellet -v flagget muliggjør detaljert utgang under testkjøring).

Makefiles gir også en enkel måte å konfigurere miljøvariabler og flagg for prosjektet ditt.

Du kan legge til disse linjene i Makefilen din hvis du trenger å angi GOOS og GOARCH variabler for å bygge prosjektet ditt for et spesifikt operativsystem eller arkitektur.

# Makefile
# Variabler
GOCMD=gå
GOBUILD=$(GOCMD) bygge
FÅTT=$(GOCMD) test
GOCLEAN=$(GOCMD) ren
BINARY_NAME=app
TEST_FLAGS=-v
GOOS=linux
GOARCH=amd64
# Mål
bygge:
$(GOBUILD) -o $(BINARY_NAME) .
test:
$(GOTEST)$(TEST_FLAGS) ./...
ren:
$(GOCLEAN)
 rm -f $(BINARY_NAME)

I den oppdaterte Makefile er det to nye variabler for GOOS og GOARCH miljøvariabler som lar deg spesifisere måloperativsystemet og arkitekturen for bygget (i dette tilfellet GOOS variabelen er satt til linux og GOARCH til amd64 å bygge prosjektet for Linux på x86-64-arkitekturen).

Husk å tilpasse disse variablene basert på prosjektets spesifikke krav.

Du kan referere til Gå dokumentasjon for listen over støttede verdier for GOOS og GOARCH hvis du trenger å bygge for en annen plattform.

Bygg automatisering med Makefiles

Makefiles er også nyttig for å kompilere kode, generere dokumentasjon og administrere avhengigheter.

Med Makefiles kan du automatisere kompileringstid, slik at du sparer tid og krefter.

Her er en Makefile som kompilerer et Go-program:

# Definer variabler
GOCMD = gå
GOBUILD = $(GOCMD) bygge
BINARY_NAME = mitt program
# Standard mål
alle: bygge
# Bygg mål
bygge:
$(GOBUILD) -o $(BINARY_NAME)
# Rent mål
ren:
 rm -f $(BINARY_NAME)

Makefilen definerer variabler som GOCMD (Gå-kommandoen) og GOBUILD (byggkommandoen). De bygge målet påkaller gå bygge kommando for å kompilere vårt Go-program og produsere binærfilen med det angitte navnet (mitt program i dette tilfellet). De ren target fjerner den genererte binære filen fra prosjektet.

Du kan bruke Makefiles til å automatisere avhengighetsinstallasjon og holde prosjektets eksterne avhengigheter oppdatert.

# Definer variabler
GOCMD = gå
GOBUILD = $(GOCMD) bygge
GOGET = $(GOCMD) få
BINARY_NAME = mitt program
# Standard mål
alle: bygge
# Bygg mål
bygge:
$(GOBUILD) -o $(BINARY_NAME)
# Installasjonsavhengigheter
deps:
$(GOGET) -u
# Rent mål
ren:
 rm -f $(BINARY_NAME)

Makefilen har en deps mål som bruker gå og hent kommando for å installere eller oppdatere prosjektavhengigheter. Du kan løpe lage deps for å installere prosjektets avhengigheter.

Makefiles kan automatisere dokumentasjonsgenerering og forbedre din dokumenter som kodeprosess.

Slik kan du autogenerer dokumentasjon for Go-prosjektene dine med godoc-verktøyet og Makefile:

# Definer variabler
GODOC = godok
DOCS_DIR = dokumenter
# Standard mål
alle: dokumenter
# Generer dokumentasjon
dokumenter:
$(GODOC) -html -dir. > $(DOCS_DIR)/index.html
# Rent mål
ren:
 rm -rf $(DOCS_DIR)

I Makefilen er det dokumenter målet påkaller godoc kommando med -html flagg for å generere HTML-dokumentasjon for go-koden din og lagrer dokumentasjonen til dokumenter katalog.

Du vil kjøre lage dokumenter kommando for å generere oppdatert dokumentasjon for ditt Go-prosjekt.

Makefiles er praktiske for å jobbe med Unix-baserte operativsystemer

Ved å utnytte fleksibiliteten til Makefiles, kan du definere egendefinerte byggekommandoer og utføre komplekse oppgaver i løpet av minutter. Makefile sparer tid og sikrer konsistens og reproduserbarhet på tvers av byggemiljøer.

En annen fordel med Makefiles er dens kompatibilitet med Unix-baserte systemer. Make er et bredt støttet verktøy på Unix-baserte operativsystemer, inkludert Linux og macOS, noe som gjør det til et bærbart og pålitelig verktøy for utviklere.