Come semplificare lo sviluppo di Go con i Makefile

Nello sviluppo software moderno, l'automazione efficiente della compilazione è fondamentale per il successo di un progetto. Makefiles, un popolare strumento di automazione della compilazione, offre agli sviluppatori di tutti gli stack un modo conciso e potente per gestire processi di compilazione complessi.

Integrando e interoperando Makefiles con Go, puoi automatizzare le attività ripetitive, semplificare i processi di creazione e migliorare la produttività.

Comprensione dei Makefile

Capire come funzionano i Makefile è fondamentale per organizzare e automatizzare in modo efficiente le build del tuo progetto.

I makefile seguono una struttura e una sintassi specifiche per la definizione delle regole per la creazione e la manutenzione dei progetti. Al centro, un Makefile è costituito da regole che specificano obiettivi, dipendenze e comandi. Ogni regola inizia con un target, seguito dalle sue dipendenze e dai comandi necessari per costruire o eseguire il target.

Gli obiettivi rappresentano i file di output desiderati o le azioni per il Makefile. Le destinazioni possono essere nomi di file o etichette che descrivono l'attività. Ad esempio, una destinazione denominata pulito può rimuovere i file non necessari generati durante il processo di compilazione.

Le dipendenze sono file o attività necessarie per la creazione di un target. Se vengono modificate delle dipendenze, il Makefile ricostruirà i target associati per garantire che le parti necessarie del progetto funzionino. Specificherai le dipendenze dopo il target, separate da spazi.

I comandi sono azioni o comandi della shell che richiedono l'esecuzione per costruire o eseguire obiettivi specifici. I comandi sono generalmente scritti in un linguaggio di scripting della shell del sistema operativo.

Ogni comando deve iniziare con un carattere di tabulazione per il riconoscimento.

build: main.go utils.go
 vai build -o miaapp main.go utils.go
pulito:
 rm miaapp

Nel Makefile sopra, ci sono due obiettivi: costruire E pulito.

IL costruire l'obiettivo dipende dal main.go E utils.go file e il comando associato viene eseguito sul compilatore Go per creare un eseguibile denominato myapp.

D'altra parte, il pulito destinazione rimuove il myapp eseguibile.

Per compilare il tuo codice Go, vai alla directory di lavoro ed esegui il file fare costruire comando.

fare costruire

Lo strumento Crea gestirà il processo di compilazione, permettendoti di concentrarti sulla scrittura del codice.

Configurazione dei Makefile per i tuoi progetti Go

Puoi utilizzare Makefile per creare e compilare i tuoi programmi, eseguire test del codice e controlli di qualità e per l'integrazione e la distribuzione continue.

Esegui questo comando per creare un Makefile per il tuo progetto nella directory principale. IL Makefile servirà come punto di ingresso per definire le attività di compilazione.

toccare Makefile

Il tuo Makefile non dovrebbe avere alcuna estensione.

Dopo aver creato il Makefile, puoi scrivere comandi, dipendenze e obiettivi nel file per le operazioni del tuo progetto.

Ecco un Makefile di esempio che funge da strumento di automazione della compilazione per il tuo progetto:

# Makefile
# Variabili
GOCMD=vai
GOBUILD=$(GOCMD) costruire
GOTEST=$(GOCMD) test
GOCLEAN=$(GOCMD) pulito
# Obiettivi
costruire:
$(GOBUILD) -o app .
test:
$(GOTEST) ./...
pulito:
$(GOCLEAN)
 rm -f app

Puoi personalizzare il tuo Makefile in base alle esigenze specifiche del tuo progetto.

Ecco una versione modificata del Makefile per passare ulteriori flag e variabili d'ambiente durante il processo di test o build del tuo progetto:

# Makefile
# Variabili
GOCMD=vai
GOBUILD=$(GOCMD) costruire
GOTEST=$(GOCMD) test
GOCLEAN=$(GOCMD) pulito
BINARY_NAME=app
TEST_FLAGS=-v
# Obiettivi
costruire:
$(GOBUILD) -o $(BINARY_NAME) .
test:
$(GOTEST)$(TEST_FLAGS) ./...
pulito:
$(GOCLEAN)
 rm -f $(BINARY_NAME)

In questo Makefile, ci sono due nuove variabili denominate BINARY_NAME E TEST_FLAGS. IL BINARY_NAME variabile specifica il nome del file eseguibile generato.

IL TEST_FLAGS La variabile consente di specificare flag aggiuntivi durante l'esecuzione dei test (in questo caso, il file - v flag abilita l'output dettagliato durante l'esecuzione del test).

Makefiles fornisce anche un modo semplice per configurare variabili di ambiente e flag per il tuo progetto.

Puoi aggiungere queste righe al tuo Makefile se hai bisogno di impostare il file GOOS E GOARCH variabili per creare il progetto per un sistema operativo o un'architettura specifici.

# Makefile
# Variabili
GOCMD=vai
GOBUILD=$(GOCMD) costruire
GOTEST=$(GOCMD) test
GOCLEAN=$(GOCMD) pulito
BINARY_NAME=app
TEST_FLAGS=-v
GOOS=linux
GOARCH=amd64
# Obiettivi
costruire:
$(GOBUILD) -o $(BINARY_NAME) .
test:
$(GOTEST)$(TEST_FLAGS) ./...
pulito:
$(GOCLEAN)
 rm -f $(BINARY_NAME)

Nel Makefile aggiornato, ci sono due nuove variabili per il file GOOS E GOARCH variabili di ambiente che consentono di specificare il sistema operativo e l'architettura di destinazione per la build (in questo caso, il file GOOS variabile è impostata su Linux E GOARCH A emendamento64 costruire il progetto per Linux sull'architettura x86-64).

Ricorda di adattare queste variabili in base ai requisiti specifici del tuo progetto.

Puoi fare riferimento al Vai alla documentazione per l'elenco dei valori supportati per GOOS E GOARCH se hai bisogno di costruire per una piattaforma diversa.

Costruisci l'automazione con i Makefile

I makefile sono utili anche per compilare codice, generare documentazione e gestire le dipendenze.

Con Makefiles puoi automatizzare i tempi di compilazione, risparmiando tempo e fatica.

Ecco un Makefile che compila un programma Go:

# Definisci variabili
GOCMD = vai
GOBUILD = $(GOCMD) costruire
BINARY_NAME = mioprogramma
# Destinazione predefinita
tutto: costruire
# Costruisci obiettivo
costruire:
$(GOBUILD) -o $(BINARY_NAME)
# Obiettivo pulito
pulito:
 rm -f $(BINARY_NAME)

Il Makefile definisce variabili come il GOCMD (il comando Vai) e GOBUILD (il comando di compilazione). IL costruire target richiama il vai a costruire comando per compilare il nostro programma Go e produrre il binario con il nome specificato (myprogram in questo caso). IL pulito target rimuove il file binario generato dal progetto.

Puoi utilizzare i Makefile per automatizzare l'installazione delle dipendenze e mantenere aggiornate le dipendenze esterne del tuo progetto.

# Definisci variabili
GOCMD = vai
GOBUILD = $(GOCMD) costruire
GOGGET = $(GOCMD) Ottenere
BINARY_NAME = mioprogramma
# Destinazione predefinita
tutto: costruire
# Costruisci obiettivo
costruire:
$(GOBUILD) -o $(BINARY_NAME)
# Installa le dipendenze
profondità:
$(GOGET) -u
# Obiettivo pulito
pulito:
 rm -f $(BINARY_NAME)

Il Makefile ha un deps destinazione che utilizza il vai a prendere comando per installare o aggiornare le dipendenze del progetto. Puoi correre fare deps per installare le dipendenze del tuo progetto.

I makefile possono automatizzare la generazione della documentazione e migliorare il tuo docs come processo di codice.

Ecco come puoi genera automaticamente la documentazione per i tuoi progetti Go con lo strumento godoc e Makefile:

# Definisci variabili
GODOC = godoc
DOCS_DIR = documenti
# Destinazione predefinita
tutto: doc
# Genera documentazione
documenti:
$(GODOC) -html -dir. > $(DOCS_DIR)/index.html
# Obiettivo pulito
pulito:
 rm-rf $(DOCS_DIR)

Nel Makefile, il documenti target richiama il godoc comandare con il -html flag per generare la documentazione HTML per il tuo codice go e salva la documentazione nel file documenti directory.

Eseguirai il fare documenti comando per generare la documentazione aggiornata per il tuo progetto Go.

I makefile sono utili per lavorare con sistemi operativi basati su Unix

Sfruttando la flessibilità dei Makefile, puoi definire comandi di build personalizzati ed eseguire attività complesse in pochi minuti. Makefile consente di risparmiare tempo e garantisce coerenza e riproducibilità in tutti gli ambienti di compilazione.

Un altro vantaggio di Makefiles è la sua compatibilità con i sistemi basati su Unix. Make è un'utilità ampiamente supportata su sistemi operativi basati su Unix, inclusi Linux e macOS, che la rende uno strumento portatile e affidabile per gli sviluppatori.