Jak usprawnić programowanie Go za pomocą plików Makefile

W nowoczesnym tworzeniu oprogramowania wydajna automatyzacja kompilacji ma kluczowe znaczenie dla powodzenia projektu. Makefiles, popularne narzędzie do automatyzacji kompilacji, zapewnia programistom wszystkich stosów zwięzły i wydajny sposób zarządzania złożonymi procesami kompilacji.

Integrując i współpracując Makefiles z Go, możesz zautomatyzować powtarzalne zadania, usprawnić procesy kompilacji i zwiększyć produktywność.

Zrozumienie Makefile

Zrozumienie, jak działają pliki Makefile, ma kluczowe znaczenie dla efektywnego organizowania i automatyzacji kompilacji projektów.

Makefile mają specyficzną strukturę i składnię do definiowania reguł budowania i utrzymywania projektów. Zasadniczo Makefile składa się z reguł określających cele, zależności i polecenia. Każda reguła zaczyna się od celu, po którym następują jego zależności i polecenia potrzebne do zbudowania lub wykonania celu.

Cele reprezentują pożądane pliki wyjściowe lub akcje dla Makefile. Cele mogą być nazwami plików lub etykietami opisującymi zadanie. Na przykład cel o nazwie

czysty może usunąć niepotrzebne pliki wygenerowane podczas procesu kompilacji.

Zależności to pliki lub zadania wymagane do zbudowania celu. Jeśli jakiekolwiek zależności zostaną zmodyfikowane, Makefile przebuduje powiązane cele, aby zapewnić, że niezbędne części projektu będą działać. Określisz zależności po celu, oddzielone spacjami.

Polecenia to działania lub polecenia powłoki które wymagają wykonania w celu zbudowania lub wykonania określonych celów. Polecenia są zwykle pisane w języku skryptowym powłoki systemu operacyjnego.

Każde polecenie musi zaczynać się od znaku tabulacji w celu rozpoznania.

kompilacja: main.go utils.go
 przejdź do kompilacji -o myapp main.go utils.go
czysty:
 rm mojaaplikacja

W powyższym Makefile są dwa cele: zbudować I czysty.

The zbudować cel zależy od main.go I utils.go plików, a powiązane polecenie jest uruchamiane w kompilatorze Go w celu zbudowania pliku wykonywalnego o nazwie mojaaplikacja.

Z drugiej strony, czysty cel usuwa mojaaplikacja wykonywalny.

Aby skompilować kod Go, przejdź do katalogu roboczego i uruchom plik zbuduj Komenda.

zbuduj

Narzędzie Make zajmie się procesem kompilacji, pozwalając skupić się na pisaniu kodu.

Konfigurowanie plików Makefile dla projektów Go

Możesz używać plików Makefile do tworzenia i kompilowania programów, przeprowadzania testów kodu i kontroli jakości oraz do ciągłej integracji i wdrażania.

Uruchom to polecenie, aby utworzyć plik Makefile dla swojego projektu w katalogu głównym. The Plik Makefile będzie służyć jako punkt wejścia do definiowania zadań kompilacji.

dotknij Makefile

Twój Makefile nie powinien mieć żadnych rozszerzeń.

Po utworzeniu pliku Makefile możesz zapisywać w nim polecenia, zależności i cele dla operacji twojego projektu.

Oto przykład Makefile, który służy jako narzędzie do automatyzacji kompilacji dla twojego projektu:

# Makefile
# Zmienne
GOCMD=idź
ZBUDOWANA=$(GOCMD) zbudować
TEST GOTOWY=$(GOCMD) test
GOCLEAN=$(GOCMD) czysty
# Cele
zbudować:
$(GOBUDOWANIE) -o aplikacja.
test:
$(TEST GOTOWY) ./...
czysty:
$(GOCLEAN)
 rm -f aplikacja

Możesz dostosować plik Makefile do konkretnych potrzeb swojego projektu.

Oto zmodyfikowana wersja pliku Makefile do przekazywania dodatkowych flag i zmiennych środowiskowych podczas procesu testowania lub budowania projektu:

# Makefile
# Zmienne
GOCMD=idź
ZBUDOWANA=$(GOCMD) zbudować
TEST GOTOWY=$(GOCMD) test
GOCLEAN=$(GOCMD) czysty
BINARY_NAME=aplikacja
TEST_FLAGS=-v
# Cele
zbudować:
$(GOBUDOWANIE) -o $(NAZWA_BINARNA) .
test:
$(TEST GOTOWY)$(TEST_FLAGS) ./...
czysty:
$(GOCLEAN)
 rm -f $(NAZWA_BINARNA)

W tym pliku Makefile znajdują się dwie nowe zmienne o nazwach BINARY_NAME I TEST_FLAGI. The BINARY_NAME zmienna określa nazwę wygenerowanego pliku wykonywalnego.

The TEST_FLAGI zmienna pozwala określić dodatkowe flagi podczas uruchamiania testów (w tym przypadku -w flag włącza szczegółowe dane wyjściowe podczas wykonywania testu).

Makefiles zapewnia również łatwy sposób konfigurowania zmiennych środowiskowych i flag dla twojego projektu.

Możesz dodać te linie do pliku Makefile, jeśli chcesz ustawić GOOS I GOARCH zmiennych, aby zbudować projekt dla określonego systemu operacyjnego lub architektury.

# Makefile
# Zmienne
GOCMD=idź
ZBUDOWANA=$(GOCMD) zbudować
TEST GOTOWY=$(GOCMD) test
GOCLEAN=$(GOCMD) czysty
BINARY_NAME=aplikacja
TEST_FLAGS=-v
GOOS=linux
GOARCH=amd64
# Cele
zbudować:
$(GOBUDOWANIE) -o $(NAZWA_BINARNA) .
test:
$(TEST GOTOWY)$(TEST_FLAGS) ./...
czysty:
$(GOCLEAN)
 rm -f $(NAZWA_BINARNA)

W zaktualizowanym pliku Makefile znajdują się dwie nowe zmienne dla GOOS I GOARCH zmienne środowiskowe, które pozwalają określić docelowy system operacyjny i architekturę kompilacji (w tym przypadku plik GOOS zmienna jest ustawiona na Linuks I GOARCH Do amd64 zbudować projekt dla Linuksa na architekturze x86-64).

Pamiętaj, aby dostosować te zmienne w oparciu o specyficzne wymagania Twojego projektu.

Możesz odnieść się do Przejdź do dokumentacji dla listy obsługiwanych wartości dla GOOS I GOARCH jeśli potrzebujesz zbudować dla innej platformy.

Buduj automatyzację za pomocą plików Makefile

Makefile są również przydatne do kompilowania kodu, generowania dokumentacji i zarządzania zależnościami.

Dzięki Makefile możesz zautomatyzować czas kompilacji, oszczędzając czas i wysiłek.

Oto Makefile, który kompiluje program Go:

# Zdefiniuj zmienne
GOCMD = idź
ZBUDOWANA = $(GOCMD) zbudować
NAZWA_BINARNA = mój program
# Domyślny cel
wszystko: buduj
# Zbuduj cel
zbudować:
$(GOBUDOWANIE) -o $(NAZWA_BINARNA)
# Czysty cel
czysty:
 rm -f $(NAZWA_BINARNA)

Makefile definiuje zmienne, takie jak GOCMD (polecenie Go) i GOBUILD (polecenie budowania). The zbudować cel wywołuje idź budować polecenie, aby skompilować nasz program Go i utworzyć plik binarny o określonej nazwie (mój program w tym przypadku). The czysty target usuwa wygenerowany plik binarny z projektu.

Możesz użyć Makefile, aby zautomatyzować instalację zależności i aktualizować zewnętrzne zależności twojego projektu.

# Zdefiniuj zmienne
GOCMD = idź
ZBUDOWANA = $(GOCMD) zbudować
GOGET = $(GOCMD) Dostawać
NAZWA_BINARNA = mój program
# Domyślny cel
wszystko: buduj
# Zbuduj cel
zbudować:
$(GOBUDOWANIE) -o $(NAZWA_BINARNA)
# Zainstaluj zależności
Dep.:
$(GOGET) -u
# Czysty cel
czysty:
 rm -f $(NAZWA_BINARNA)

Makefile ma plik dep cel, który używa idź po polecenie, aby zainstalować lub zaktualizować zależności projektu. Możesz biegać zrobić dep aby zainstalować zależności twojego projektu.

Makefile mogą zautomatyzować generowanie dokumentacji i ulepszyć Twoje docs jako proces kodu.

Oto jak możesz automatycznie generuj dokumentację swoich projektów Go za pomocą narzędzia godoc i Makefile:

# Zdefiniuj zmienne
GODOC = godok
DOCS_DIR = dokumenty
# Domyślny cel
wszystko: dok
# Generuj dokumentację
dokumenty:
$(GODOC) -html -reż. > $(DOCS_DIR)/index.html
# Czysty cel
czysty:
 rm-rf $(DOCS_DIR)

W Makefile, dokumenty cel wywołuje Godok polecenie z -html flag, aby wygenerować dokumentację HTML dla twojego kodu go i zapisać dokumentację w dokumenty informator.

Uruchomisz robić dokumenty polecenie do generowania aktualnej dokumentacji dla Twojego projektu Go.

Makefile są przydatne do pracy z systemami operacyjnymi opartymi na Uniksie

Wykorzystując elastyczność Makefile, możesz definiować niestandardowe polecenia kompilacji i wykonywać złożone zadania w ciągu kilku minut. Makefile oszczędza czas i zapewnia spójność i powtarzalność w różnych środowiskach kompilacji.

Kolejną zaletą Makefile jest kompatybilność z systemami opartymi na Uniksie. Make to szeroko obsługiwane narzędzie w systemach operacyjnych opartych na Uniksie, w tym Linux i macOS, dzięki czemu jest przenośnym i niezawodnym narzędziem dla programistów.