Machen Sie Ihr Leben einfacher, indem Sie sich wiederholende Aufgaben mithilfe von Makefiles automatisieren.
In der modernen Softwareentwicklung ist eine effiziente Build-Automatisierung entscheidend für den Erfolg eines Projekts. Makefiles, ein beliebtes Build-Automatisierungstool, bietet Entwicklern aller Stacks eine übersichtliche und leistungsstarke Möglichkeit, komplexe Build-Prozesse zu verwalten.
Durch die Integration und Zusammenarbeit von Makefiles mit Go können Sie sich wiederholende Aufgaben automatisieren, Build-Prozesse rationalisieren und die Produktivität steigern.
Makefiles verstehen
Für die effiziente Organisation und Automatisierung Ihrer Projekterstellungen ist es von entscheidender Bedeutung, zu verstehen, wie Makefiles funktionieren.
Makefiles folgen einer bestimmten Struktur und Syntax zum Definieren von Regeln zum Erstellen und Verwalten von Projekten. Im Kern besteht ein Makefile aus Regeln, die Ziele, Abhängigkeiten und Befehle festlegen. Jede Regel beginnt mit einem Ziel, gefolgt von seinen Abhängigkeiten und den Befehlen, die zum Erstellen oder Ausführen des Ziels erforderlich sind.
Ziele stellen die gewünschten Ausgabedateien oder Aktionen für das Makefile dar. Ziele können Dateinamen oder Labels sein, die die Aufgabe beschreiben. Zum Beispiel ein Ziel mit dem Namen sauber entfernt möglicherweise unnötige Dateien, die während des Erstellungsprozesses generiert wurden.
Abhängigkeiten sind Dateien oder Aufgaben, die zum Erstellen eines Ziels erforderlich sind. Wenn Abhängigkeiten geändert werden, erstellt das Makefile die zugehörigen Ziele neu, um sicherzustellen, dass die erforderlichen Teile des Projekts funktionieren. Sie geben Abhängigkeiten nach dem Ziel an, getrennt durch Leerzeichen.
Befehle sind Aktionen bzw Shell-Befehle die ausgeführt werden müssen, um bestimmte Ziele zu erstellen oder auszuführen. Befehle werden normalerweise in einer Shell-Skriptsprache des Betriebssystems geschrieben.
Zur Erkennung muss jeder Befehl mit einem Tabulatorzeichen beginnen.
Build: main.go utils.go
go build -o myapp main.go utils.go
sauber:
rm myapp
Im obigen Makefile gibt es zwei Ziele: bauen Und sauber.
Der bauen Ziel hängt von der ab main.go Und utils.go Dateien, und der zugehörige Befehl wird auf dem Go-Compiler ausgeführt, um eine ausführbare Datei mit dem Namen zu erstellen meine App.
Andererseits ist die sauber Ziel entfernt die meine App ausführbar.
Um Ihren Go-Code zu kompilieren, navigieren Sie zum Arbeitsverzeichnis und führen Sie Folgendes aus bauen machen Befehl.
bauen machen
Das Make-Tool übernimmt den Kompilierungsprozess, sodass Sie sich auf das Schreiben von Code konzentrieren können.
Einrichten von Makefiles für Ihre Go-Projekte
Sie können Makefiles verwenden, um Ihre Programme zu erstellen und zu kompilieren, Codetests und Qualitätsprüfungen durchzuführen sowie für die kontinuierliche Integration und Bereitstellung.
Führen Sie diesen Befehl aus, um ein Makefile für Ihr Projekt im Stammverzeichnis zu erstellen. Der Makefile dient als Einstiegspunkt für die Definition Ihrer Build-Aufgaben.
Berühren Sie Makefile
Ihr Makefile sollte keine Erweiterungen haben.
Nachdem Sie das Makefile erstellt haben, können Sie Befehle, Abhängigkeiten und Ziele für die Vorgänge Ihres Projekts in die Datei schreiben.
Hier ist ein Beispiel-Makefile, das als Build-Automatisierungstool für Ihr Projekt dient:
# Makefile# Variablen
GOCMD=gehen
GOBUILD=$(GOCMD) bauen
GOTEST=$(GOCMD) prüfen
GOCLEAN=$(GOCMD) sauber# Ziele
bauen:
$(GOBUILD) -o App .prüfen:
$(GOTEST) ./...
sauber:
$(GOCLEAN)
rm -f app
Sie können Ihr Makefile an die spezifischen Anforderungen Ihres Projekts anpassen.
Hier ist eine modifizierte Version des Makefiles zum Übergeben zusätzlicher Flags und Umgebungsvariablen während des Test- oder Build-Prozesses Ihres Projekts:
# Makefile# Variablen
GOCMD=gehen
GOBUILD=$(GOCMD) bauen
GOTEST=$(GOCMD) prüfen
GOCLEAN=$(GOCMD) sauber
BINARY_NAME=App
TEST_FLAGS=-v# Ziele
bauen:
$(GOBUILD) -Ö $(BINARY_NAME) .prüfen:
$(GOTEST)$(TEST_FLAGS) ./...
sauber:
$(GOCLEAN)
rm -f $(BINARY_NAME)
In diesem Makefile gibt es zwei neue Variablen mit dem Namen BINARY_NAME Und TEST_FLAGS. Der BINARY_NAME Variable gibt den Namen der generierten ausführbaren Datei an.
Der TEST_FLAGS Mit der Variable können Sie beim Ausführen von Tests zusätzliche Flags angeben (in diesem Fall die -v Flag ermöglicht ausführliche Ausgabe während der Testausführung).
Makefiles bietet außerdem eine einfache Möglichkeit, Umgebungsvariablen und Flags für Ihr Projekt zu konfigurieren.
Sie können diese Zeilen zu Ihrem Makefile hinzufügen, wenn Sie das festlegen müssen GOOS Und GOARCH Variablen, um Ihr Projekt für ein bestimmtes Betriebssystem oder eine bestimmte Architektur zu erstellen.
# Makefile# Variablen
GOCMD=gehen
GOBUILD=$(GOCMD) bauen
GOTEST=$(GOCMD) prüfen
GOCLEAN=$(GOCMD) sauber
BINARY_NAME=App
TEST_FLAGS=-v
GOOS=Linux
GOARCH=amd64# Ziele
bauen:
$(GOBUILD) -Ö $(BINARY_NAME) .prüfen:
$(GOTEST)$(TEST_FLAGS) ./...
sauber:
$(GOCLEAN)
rm -f $(BINARY_NAME)
Im aktualisierten Makefile gibt es zwei neue Variablen für GOOS Und GOARCH Umgebungsvariablen, mit denen Sie das Zielbetriebssystem und die Zielarchitektur für Ihren Build angeben können (in diesem Fall die GOOS Variable ist auf gesetzt Linux Und GOARCH Zu amd64 um das Projekt für Linux auf der x86-64-Architektur zu erstellen).
Denken Sie daran, diese Variablen entsprechend den spezifischen Anforderungen Ihres Projekts anzupassen.
Sie können sich auf die beziehen Gehen Sie zur Dokumentation für die Liste der unterstützten Werte für GOOS Und GOARCH wenn Sie für eine andere Plattform bauen müssen.
Erstellen Sie Automatisierung mit Makefiles
Makefiles sind auch praktisch zum Kompilieren von Code, zum Generieren von Dokumentation und zum Verwalten von Abhängigkeiten.
Mit Makefiles können Sie die Kompilierungszeit automatisieren und so Zeit und Mühe sparen.
Hier ist ein Makefile, das ein Go-Programm kompiliert:
# Variablen definieren
GOCMD = los
GOBUILD = $(GOCMD) bauen
BINARY_NAME = mein Programm# Standardziel
alle: bauen# Ziel erstellen
bauen:
$(GOBUILD) -Ö $(BINARY_NAME)
# Ziel reinigen
sauber:
rm -f $(BINARY_NAME)
Das Makefile definiert Variablen wie die GOCMD (der Go-Befehl) und GOBUILD (der Build-Befehl). Der bauen target ruft die auf geh bauen Befehl zum Kompilieren unseres Go-Programms und zum Erstellen der Binärdatei mit dem angegebenen Namen (meinProgramm in diesem Fall). Der sauber target entfernt die generierte Binärdatei aus dem Projekt.
Sie können Makefiles verwenden, um die Installation von Abhängigkeiten zu automatisieren und die externen Abhängigkeiten Ihres Projekts auf dem neuesten Stand zu halten.
# Variablen definieren
GOCMD = los
GOBUILD = $(GOCMD) bauen
GOGET = $(GOCMD) erhalten
BINARY_NAME = mein Programm# Standardziel
alle: bauen# Ziel erstellen
bauen:
$(GOBUILD) -Ö $(BINARY_NAME)# Abhängigkeiten installieren
abhängig:
$(GOGET) -u
# Ziel reinigen
sauber:
rm -f $(BINARY_NAME)
Das Makefile hat eine deps Ziel, das das verwendet geh holen Befehl zum Installieren oder Aktualisieren von Projektabhängigkeiten. Du kannst rennen machen deps um die Abhängigkeiten Ihres Projekts zu installieren.
Makefiles können die Dokumentationserstellung automatisieren und Ihre Dokumentation verbessern Dokumente als Codeprozess.
Hier erfahren Sie, wie Sie es können Erstellen Sie mit dem Godoc-Tool automatisch eine Dokumentation für Ihre Go-Projekte und Makefile:
# Variablen definieren
GODOC = godoc
DOCS_DIR = Dokumente# Standardziel
alle: Dokumente# Dokumentation erstellen
Dokumente:
$(GODOC) -html -dir. > $(DOCS_DIR)/index.html
# Ziel reinigen
sauber:
rm -rf $(DOCS_DIR)
Im Makefile ist die Dokumente target ruft die auf godoc Befehl mit dem -html Flag, um eine HTML-Dokumentation für Ihren Go-Code zu generieren und die Dokumentation im zu speichern Dokumente Verzeichnis.
Sie werden das ausführen Dokumente erstellen Befehl zum Generieren einer aktuellen Dokumentation für Ihr Go-Projekt.
Makefiles sind praktisch für die Arbeit mit Unix-basierten Betriebssystemen
Durch die Nutzung der Flexibilität von Makefiles können Sie benutzerdefinierte Build-Befehle definieren und komplexe Aufgaben innerhalb von Minuten ausführen. Makefile spart Zeit und gewährleistet Konsistenz und Reproduzierbarkeit in allen Build-Umgebungen.
Ein weiterer Vorteil von Makefiles ist die Kompatibilität mit Unix-basierten Systemen. Make ist ein weithin unterstütztes Dienstprogramm auf Unix-basierten Betriebssystemen, einschließlich Linux und macOS, was es zu einem portablen und zuverlässigen Tool für Entwickler macht.
