Home-theater-designers
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à.
MAKEUSEOF VIDEO DEL GIORNO SCORRI PER CONTINUARE CON I CONTENUTI
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 obiettivo. 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
go build -o myapp main.go utils.go
clean:
rm myapp
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 .
come ridurre l'utilizzo della ram di google chrome
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.
make build
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.
touch 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
# Variables
GOCMD=go
GOBUILD=$(GOCMD) build
GOTEST=$(GOCMD) test
GOCLEAN=$(GOCMD) clean
# Targets
build:
$(GOBUILD) -o app .
test:
$(GOTEST) ./...
clean:
$(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
# Variables
GOCMD=go
GOBUILD=$(GOCMD) build
GOTEST=$(GOCMD) test
GOCLEAN=$(GOCMD) clean
BINARY_NAME=app
TEST_FLAGS=-v
# Targets
build:
$(GOBUILD) -o $(BINARY_NAME) .
test:
$(GOTEST) $(TEST_FLAGS) ./...
clean:
$(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 -In 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
# Variables
GOCMD=go
GOBUILD=$(GOCMD) build
GOTEST=$(GOCMD) test
GOCLEAN=$(GOCMD) clean
BINARY_NAME=app
TEST_FLAGS=-v
GOOS=linux
GOARCH=amd64
# Targets
build:
$(GOBUILD) -o $(BINARY_NAME) .
test:
$(GOTEST) $(TEST_FLAGS) ./...
clean:
$(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:
# Define variables
GOCMD = go
GOBUILD = $(GOCMD) build
BINARY_NAME = myprogram
# Default target
all: build
# Build target
build:
$(GOBUILD) -o $(BINARY_NAME)
# Clean target
clean:
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.
# Define variables
GOCMD = go
GOBUILD = $(GOCMD) build
GOGET = $(GOCMD) get
BINARY_NAME = myprogram
# Default target
all: build
# Build target
build:
$(GOBUILD) -o $(BINARY_NAME)
# Install dependencies
deps:
$(GOGET) -u
# Clean target
clean:
rm -f $(BINARY_NAME)
Il Makefile ha un Dipartimento 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:
# Define variables
GODOC = godoc
DOCS_DIR = docs
# Default target
all: docs
# Generate documentation
docs:
$(GODOC) -html -dir . > $(DOCS_DIR)/index.html
# Clean target
clean:
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.