Paano I-streamline ang Iyong Go Development Gamit ang Makefiles

Paano I-streamline ang Iyong Go Development Gamit ang Makefiles
Ang mga mambabasang tulad mo ay tumutulong sa pagsuporta sa MUO. Kapag bumili ka gamit ang mga link sa aming site, maaari kaming makakuha ng isang affiliate na komisyon. Magbasa pa.

Sa modernong software development, ang mahusay na build automation ay mahalaga para sa tagumpay ng isang proyekto. Ang Makefiles, isang sikat na tool sa pag-automate ng build, ay nagbibigay sa mga developer ng lahat ng mga stack ng maikli at mahusay na paraan upang pamahalaan ang mga kumplikadong proseso ng build.





Sa pamamagitan ng pagsasama at pag-interoperate ng Makefiles sa Go, maaari mong i-automate ang mga paulit-ulit na gawain, i-streamline ang mga proseso ng pagbuo at pahusayin ang pagiging produktibo.



kung paano upang harangan ang mga email sa gmail sa iphone
MAKEUSEOF VIDEO OF THE DAY MAG-SCROLL PARA MAGPATULOY SA NILALAMAN

Pag-unawa sa Makefiles

ang sikat na makefile logo

Ang pag-unawa sa kung paano gumagana ang Makefiles ay napakahalaga para sa mahusay na pag-aayos at pag-automate ng iyong mga pagbuo ng proyekto.





Ang mga makefile ay sumusunod sa isang partikular na istraktura at syntax para sa pagtukoy ng mga panuntunan para sa pagbuo at pagpapanatili ng mga proyekto. Sa ubod, ang isang Makefile ay binubuo ng mga panuntunang tumutukoy sa mga target, dependency, at mga utos. Ang bawat panuntunan ay nagsisimula sa isang target, na sinusundan ng mga dependency nito at ang mga utos na kailangan para mabuo o maisakatuparan ang target.

Kinakatawan ng mga target ang nais na mga output file o aksyon para sa Makefile. Ang mga target ay maaaring mga filename o label na naglalarawan sa gawain. Halimbawa, isang target na pinangalanan malinis maaaring mag-alis ng mga hindi kinakailangang file na nabuo sa panahon ng proseso ng pagbuo.



Ang mga dependency ay mga file o mga gawain na kinakailangan para sa pagbuo ng isang target. Kung ang anumang dependencies ay binago, ang Makefile ay muling bubuo ng mga nauugnay na target upang matiyak na ang mga kinakailangang bahagi ng proyekto ay gumagana. Tutukuyin mo ang mga dependency pagkatapos ng target, na pinaghihiwalay ng mga puwang.

Ang mga utos ay mga aksyon o mga utos ng shell na nangangailangan ng pagpapatupad upang bumuo o magsagawa ng mga partikular na target. Karaniwang isinusulat ang mga command sa isang shell scripting language ng operating system.



Ang bawat command ay dapat magsimula sa isang tab na character para sa pagkilala.

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

Sa Makefile sa itaas, mayroong dalawang target: magtayo at malinis .



Ang magtayo ang target ay depende sa main.go at utils.go file, at ang nauugnay na command ay tumatakbo sa Go compiler upang bumuo ng isang executable na pinangalanan myapp .

Sa kabilang banda, ang malinis tinatanggal ng target ang myapp maipapatupad.

Upang i-compile ang iyong Go code, mag-navigate sa gumaganang direktoryo at patakbuhin ang gumawa ng build utos.

 make build

Hahawakan ng Make tool ang proseso ng compilation, na magbibigay-daan sa iyong tumuon sa pagsulat ng code.

Pagse-set Up ng Mga Makefile para sa Iyong Mga Proyekto sa Go

Maaari mong gamitin ang Makefiles upang bumuo at mag-compile ng iyong mga programa, magsagawa ng mga pagsubok sa code at pagsusuri sa kalidad, at para sa patuloy na pagsasama at pag-deploy.

Patakbuhin ang command na ito upang lumikha ng Makefile para sa iyong proyekto sa root directory. Ang Makefile magsisilbing entry point para sa pagtukoy sa iyong mga gawain sa pagbuo.

 touch Makefile

Ang iyong Makefile ay hindi dapat magkaroon ng anumang mga extension.

Pagkatapos gawin ang Makefile, maaari kang magsulat ng mga command, dependency, at mga target sa file para sa mga operasyon ng iyong proyekto.

Narito ang isang halimbawa ng Makefile na nagsisilbing tool sa pagbuo ng automation para sa iyong proyekto:

 # 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

Maaari mong i-customize ang iyong Makefile ayon sa mga partikular na pangangailangan ng iyong proyekto.

Narito ang isang binagong bersyon ng Makefile para sa pagpasa ng mga karagdagang flag at environment variable sa panahon ng pagsubok o proseso ng pagbuo ng iyong proyekto:

 # 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)

Sa Makefile na ito, mayroong dalawang bagong variable na pinangalanan BINARY_NAME at TEST_FLAGS . Ang BINARY_NAME Tinutukoy ng variable ang pangalan ng nabuong executable file.

Ang TEST_FLAGS variable ay nagbibigay-daan sa iyo na tukuyin ang mga karagdagang flag kapag nagpapatakbo ng mga pagsubok (sa kasong ito, ang -sa pinapagana ng flag ang verbose output sa panahon ng pagsasagawa ng pagsubok).

Nagbibigay din ang Makefiles ng madaling paraan upang i-configure ang mga variable at flag ng kapaligiran para sa iyong proyekto.

Maaari mong idagdag ang mga linyang ito sa iyong Makefile kung kailangan mong itakda ang GOOS at GOARCH mga variable upang buuin ang iyong proyekto para sa isang partikular na operating system o arkitektura.

 # 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)

Sa na-update na Makefile, mayroong dalawang bagong variable para sa GOOS at GOARCH environment variable na nagbibigay-daan sa iyong tukuyin ang target na operating system at arkitektura para sa iyong build (sa kasong ito, ang GOOS variable ay nakatakda sa linux at GOARCH sa amd64 upang bumuo ng proyekto para sa Linux sa x86-64 architecture).

Tandaan na iakma ang mga variable na ito batay sa mga partikular na kinakailangan ng iyong proyekto.

Maaari kang sumangguni sa Pumunta sa dokumentasyon para sa listahan ng mga sinusuportahang halaga para sa GOOS at GOARCH kung kailangan mong bumuo para sa ibang platform.

Bumuo ng Automation Gamit ang Makefiles

Magagamit din ang Makefiles para sa pag-compile ng code, pagbuo ng dokumentasyon, at pamamahala ng mga dependency.

Sa Makefiles, maaari mong i-automate ang oras ng compilation, na makakatipid sa iyo ng oras at pagsisikap.

Narito ang isang Makefile na nag-compile ng isang Go program:

 # 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)

Ang Makefile ay tumutukoy sa mga variable tulad ng GOCMD (ang Go command) at GOBUILD (ang build command). Ang magtayo target invokes ang magtayo ka command na i-compile ang aming Go program at gawin ang binary na may tinukoy na pangalan ( myprogram sa kasong ito). Ang malinis Tinatanggal ng target ang nabuong binary mula sa proyekto.

makefile sa aksyon para sa pagbuo ng mga programa

Maaari mong gamitin ang Makefiles upang i-automate ang pag-install ng dependency at panatilihing na-update ang mga external na dependency ng iyong proyekto.

 # 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)

Ang Makefile ay may isang dept target na gumagamit ng Kunin mo utos na mag-install o mag-update ng mga dependency ng proyekto. Maaari kang tumakbo gumawa ng deps upang i-install ang mga dependency ng iyong proyekto.

Maaaring i-automate ng Makefiles ang pagbuo ng dokumentasyon at pagbutihin ang iyong docs bilang proseso ng code .

damit mula sa mga palabas sa tv at pelikula

Narito kung paano mo magagawa awtomatikong bumuo ng dokumentasyon para sa iyong mga proyekto sa Go gamit ang godoc tool at 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)

Sa Makefile, ang mga doc target invokes ang godoc utos kasama ang -html flag para bumuo ng HTML na dokumentasyon para sa iyong go code at i-save ang dokumentasyon sa mga doc direktoryo.

Tatakbuhin mo ang gumawa ng mga doc command na bumuo ng up-to-date na dokumentasyon para sa iyong proyekto sa Go.

Ang Makefiles ay Magagamit para sa Paggawa Gamit ang Unix-Based Operating System

Sa pamamagitan ng paggamit ng flexibility ng Makefiles, maaari mong tukuyin ang mga custom na build command at magsagawa ng mga kumplikadong gawain sa loob ng ilang minuto. Ang Makefile ay nakakatipid ng oras at tinitiyak ang pagkakapare-pareho at muling paggawa sa mga build environment.

Ang isa pang bentahe ng Makefiles ay ang pagiging tugma nito sa mga sistemang nakabatay sa Unix. Ang Make ay isang malawak na sinusuportahang utility sa mga operating system na nakabatay sa Unix, kabilang ang Linux at macOS, na ginagawa itong isang portable at maaasahang tool para sa mga developer.