Cum să-ți eficientizezi dezvoltarea Go cu Makefiles

În dezvoltarea software-ului modern, automatizarea eficientă a construcției este crucială pentru succesul unui proiect. Makefiles, un instrument popular de automatizare a construcției, oferă dezvoltatorilor tuturor stivelor o modalitate concisă și puternică de a gestiona procesele complexe de construire.

Prin integrarea și interoperarea Makefiles cu Go, puteți automatiza sarcini repetitive, simplifica procesele de construire și crește productivitatea.

Înțelegerea Makefiles

Înțelegerea modului în care funcționează Makefiles este crucială pentru organizarea și automatizarea eficientă a proiectelor dvs.

Makefiles urmează o structură și o sintaxă specifice pentru definirea regulilor pentru construirea și întreținerea proiectelor. În esență, un Makefile constă din reguli care specifică ținte, dependențe și comenzi. Fiecare regulă începe cu o țintă, urmată de dependențele acesteia și de comenzile necesare pentru a construi sau executa ținta.

Țintele reprezintă fișierele de ieșire sau acțiunile dorite pentru Makefile. Țintele pot fi nume de fișiere sau etichete care descriu sarcina. De exemplu, o țintă numită curat poate elimina fișierele inutile generate în timpul procesului de construire.

Dependențele sunt fișiere sau sarcini necesare pentru construirea unei ținte. Dacă se modifică orice dependențe, Makefile va reconstrui ținte asociate pentru a se asigura că părțile necesare ale proiectului funcționează. Veți specifica dependențele după țintă, separate prin spații.

Comenzile sunt acțiuni sau comenzi shell care au nevoie de execuție pentru a construi sau a realiza obiective specifice. Comenzile sunt de obicei scrise într-un limbaj de scripting shell al sistemului de operare.

Fiecare comandă trebuie să înceapă cu un caracter tabulator pentru recunoaștere.

build: main.go utils.go
 go build -o myapp main.go utils.go
curat:
 rm myapp

În Makefile de mai sus, există două ținte: construi și curat.

The construi ținta depinde de principal.go și utils.go fișiere, iar comanda asociată rulează pe compilatorul Go pentru a construi un executabil numit aplicația mea.

Pe de altă parte, cel curat ținta elimină aplicația mea executabil.

Pentru a compila codul Go, navigați la directorul de lucru și rulați face construi comanda.

face construi

Instrumentul Make se va ocupa de procesul de compilare, permițându-vă să vă concentrați pe scrierea codului.

Configurarea Makefiles pentru proiectele dvs. Go

Puteți folosi Makefiles pentru a construi și a compila programele dvs., pentru a efectua teste de cod și verificări de calitate și pentru integrare și implementare continuă.

Rulați această comandă pentru a crea un Makefile pentru proiectul dvs. în directorul rădăcină. The Makefile va servi drept punct de intrare pentru definirea sarcinilor de construcție.

atingeți Makefile

Makefile-ul dvs. nu ar trebui să aibă extensii.

După crearea fișierului Makefile, puteți scrie comenzi, dependențe și ținte în fișier pentru operațiunile proiectului.

Iată un exemplu Makefile care servește ca instrument de automatizare a construcției pentru proiectul dvs.:

# Makefile
# Variabile
GOCMD=du-te
GOBUILD=$(GOCMD) construi
GOTEST=$(GOCMD) Test
GOCLEAN=$(GOCMD) curat
# Ținte
construi:
$(GOBUILD) -o aplicație.
Test:
$(GOTEST) ./...
curat:
$(GOCLEAN)
 rm -f aplicație

Vă puteți personaliza Makefile în funcție de nevoile specifice ale proiectului.

Iată o versiune modificată a fișierului Makefile pentru a trece indicatoare suplimentare și variabile de mediu în timpul procesului de testare sau de construire a proiectului:

# Makefile
# Variabile
GOCMD=du-te
GOBUILD=$(GOCMD) construi
GOTEST=$(GOCMD) Test
GOCLEAN=$(GOCMD) curat
BINARY_NAME=aplicație
TEST_FLAGS=-v
# Ținte
construi:
$(GOBUILD) -o $(BINARY_NAME) .
Test:
$(GOTEST)$(TEST_FLAGS) ./...
curat:
$(GOCLEAN)
 rm -f $(BINARY_NAME)

În acest Makefile, există două variabile noi numite BINARY_NAME și TEST_FLAGS. The BINARY_NAME variabila specifică numele fișierului executabil generat.

The TEST_FLAGS variabila vă permite să specificați steaguri suplimentare atunci când rulați teste (în acest caz, -v flag activează ieșirea verbosă în timpul execuției testului).

Makefiles oferă, de asemenea, o modalitate ușoară de a configura variabilele de mediu și semnalizatoarele pentru proiectul dvs.

Puteți adăuga aceste linii la Makefile dacă trebuie să setați GOOS și GOARCH variabile pentru a vă construi proiectul pentru un anumit sistem de operare sau arhitectură.

# Makefile
# Variabile
GOCMD=du-te
GOBUILD=$(GOCMD) construi
GOTEST=$(GOCMD) Test
GOCLEAN=$(GOCMD) curat
BINARY_NAME=aplicație
TEST_FLAGS=-v
GOOS=linux
GARCH=amd64
# Ținte
construi:
$(GOBUILD) -o $(BINARY_NAME) .
Test:
$(GOTEST)$(TEST_FLAGS) ./...
curat:
$(GOCLEAN)
 rm -f $(BINARY_NAME)

În Makefile actualizat, există două variabile noi pentru GOOS și GOARCH variabile de mediu care vă permit să specificați sistemul de operare și arhitectura țintă pentru construcția dvs. (în acest caz, GOOS variabila este setată la linux și GOARCH la amd64 pentru a construi proiectul pentru Linux pe arhitectura x86-64).

Nu uitați să adaptați aceste variabile în funcție de cerințele specifice ale proiectului dvs.

Vă puteți referi la Du-te la documentare pentru lista de valori suportate pentru GOOS și GOARCH dacă trebuie să construiți pentru o altă platformă.

Construiți automatizare cu Makefiles

Makefile-urile sunt, de asemenea, utile pentru compilarea codului, generarea de documentație și gestionarea dependențelor.

Cu Makefiles, puteți automatiza timpul de compilare, economisind timp și efort.

Iată un Makefile care compilează un program Go:

# Definiți variabile
GOCMD = du-te
GOBUILD = $(GOCMD) construi
BINARY_NAME = programul meu
# Țintă implicită
toate: construi
# Construiți ținta
construi:
$(GOBUILD) -o $(BINARY_NAME)
# Țintă curată
curat:
 rm -f $(BINARY_NAME)

Makefile definește variabile precum GOCMD (comanda Go) și GOBUILD (comanda de construire). The construi ținta invocă mergi sa construiesti comandă pentru a compila programul nostru Go și pentru a produce binarul cu numele specificat (programul meu în acest caz). The curat target elimină binarul generat din proiect.

Puteți utiliza Makefiles pentru a automatiza instalarea dependențelor și pentru a menține actualizate dependențele externe ale proiectului.

# Definiți variabile
GOCMD = du-te
GOBUILD = $(GOCMD) construi
GOGET = $(GOCMD) obține
BINARY_NAME = programul meu
# Țintă implicită
toate: construi
# Construiți ținta
construi:
$(GOBUILD) -o $(BINARY_NAME)
# Instalați dependențe
deps:
$(GOGET) -u
# Țintă curată
curat:
 rm -f $(BINARY_NAME)

Makefile are un deps ținta care folosește du-te și ia comandă pentru a instala sau actualiza dependențele proiectului. Poți să alergi face deps pentru a instala dependențele proiectului dvs.

Makefiles poate automatiza generarea de documentație și vă poate îmbunătăți docs ca proces de cod.

Iată cum poți generați automat documentația pentru proiectele dvs. Go cu instrumentul godoc și Makefile:

# Definiți variabile
GODOC = godoc
DOCS_DIR = docs
# Țintă implicită
toate: docs
# Generați documentație
documente:
$(GODOC) -html -dir. > $(DOCS_DIR)/index.html
# Țintă curată
curat:
 rm -rf $(DOCS_DIR)

În Makefile, fișierul docs ținta invocă godoc comanda cu -html flag pentru a genera documentație HTML pentru codul dvs. go și salvează documentația în docs director.

Vei rula face docs comandă pentru a genera documentație actualizată pentru proiectul dvs. Go.

Makefiles sunt utile pentru a lucra cu sisteme de operare bazate pe Unix

Profitând de flexibilitatea Makefiles, puteți defini comenzi de construire personalizate și puteți executa sarcini complexe în câteva minute. Makefile economisește timp și asigură consistența și reproductibilitatea în mediile de construcție.

Un alt avantaj al Makefiles este compatibilitatea cu sistemele bazate pe Unix. Make este un utilitar acceptat pe scară largă pe sistemele de operare bazate pe Unix, inclusiv Linux și macOS, ceea ce îl face un instrument portabil și de încredere pentru dezvoltatori.