Cara Merampingkan Pengembangan Go Anda Dengan Makefiles

Dalam pengembangan perangkat lunak modern, otomatisasi build yang efisien sangat penting untuk keberhasilan proyek. Makefiles, alat otomasi build yang populer, memberi developer semua stack cara yang ringkas dan andal untuk mengelola proses build yang rumit.

Dengan mengintegrasikan dan menginteroperasikan Makefile dengan Go, Anda dapat mengotomatiskan tugas berulang, merampingkan proses pembangunan, dan meningkatkan produktivitas.

Memahami Makefile

Baca Juga:

Mau Berkarir di Dunia blockchain? Ini Dia 10 Skill yang Harus Kamu Dalami!

Memahami cara kerja Makefile sangat penting untuk mengatur dan mengotomatiskan pembangunan proyek Anda secara efisien.

Makefile mengikuti struktur dan sintaks khusus untuk menentukan aturan untuk membangun dan memelihara proyek. Intinya, Makefile terdiri dari aturan yang menentukan target, dependensi, dan perintah. Setiap aturan dimulai dengan target, diikuti dengan dependensinya dan perintah yang diperlukan untuk membangun atau mengeksekusi target.

Target mewakili file keluaran atau tindakan yang diinginkan untuk Makefile. Target dapat berupa nama file atau label yang mendeskripsikan tugas. Misalnya, target bernama membersihkan dapat menghapus file yang tidak diperlukan yang dihasilkan selama proses pembangunan.

Ketergantungan adalah file atau tugas yang diperlukan untuk membangun target. Jika ada dependensi yang dimodifikasi, Makefile akan membangun kembali target terkait untuk memastikan bahwa bagian yang diperlukan dari fungsi proyek. Anda akan menentukan dependensi setelah target, dipisahkan dengan spasi.

Perintah adalah tindakan atau perintah shell yang membutuhkan eksekusi untuk membangun atau melakukan target tertentu. Perintah biasanya ditulis dalam bahasa scripting shell dari sistem operasi.

Setiap perintah harus dimulai dengan karakter tab untuk dikenali.

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

Di Makefile di atas, ada dua target: membangun Dan membersihkan.

Itu membangun sasaran tergantung pada main.go Dan utils.go file, dan perintah terkait dijalankan pada kompiler Go untuk membuat nama yang dapat dieksekusi myapp.

Di sisi lain, membersihkan target menghilangkan myapp dapat dieksekusi.

Untuk mengompilasi kode Go Anda, arahkan ke direktori kerja dan jalankan membuat bangunan memerintah.

 make build
 

Alat Make akan menangani proses kompilasi, memungkinkan Anda untuk fokus menulis kode.

Menyiapkan Makefile untuk Proyek Go Anda

Anda dapat menggunakan Makefiles untuk membuat dan mengompilasi program Anda, melakukan pengujian kode dan pemeriksaan kualitas, serta untuk integrasi dan penerapan berkelanjutan.

Jalankan perintah ini untuk membuat Makefile untuk proyek Anda di direktori root. Itu Makefile akan berfungsi sebagai titik masuk untuk menentukan tugas build Anda.

 touch Makefile
 

Makefile Anda seharusnya tidak memiliki ekstensi apa pun.

Setelah membuat Makefile, Anda dapat menulis perintah, dependensi, dan target ke file untuk operasi proyek Anda.

Berikut adalah contoh Makefile yang berfungsi sebagai alat otomasi build untuk proyek Anda:

 

GOCMD=go
GOBUILD=$(GOCMD) build
GOTEST=$(GOCMD) test
GOCLEAN=$(GOCMD) clean

build:
    $(GOBUILD) -o app .
test:
    $(GOTEST) ./...
clean:
    $(GOCLEAN)
    rm -f app
 

Anda dapat menyesuaikan Makefile Anda sesuai dengan kebutuhan khusus proyek Anda.

Berikut adalah versi Makefile yang dimodifikasi untuk meneruskan flag tambahan dan variabel lingkungan selama proses pengujian atau pembangunan proyek Anda:

 

GOCMD=go
GOBUILD=$(GOCMD) build
GOTEST=$(GOCMD) test
GOCLEAN=$(GOCMD) clean
BINARY_NAME=app
TEST_FLAGS=-v

build:
    $(GOBUILD) -o $(BINARY_NAME) .
test:
    $(GOTEST) $(TEST_FLAGS) ./...
clean:
    $(GOCLEAN)
    rm -f $(BINARY_NAME)
 

Di Makefile ini, ada dua variabel baru bernama NAMA_BINARY Dan TEST_FLAGS. Itu NAMA_BINARY variabel menentukan nama file yang dapat dieksekusi yang dihasilkan.

Itu TEST_FLAGS variabel memungkinkan Anda untuk menentukan flag tambahan saat menjalankan tes (dalam hal ini, the -v flag memungkinkan output verbose selama eksekusi tes).

Makefiles juga menyediakan cara mudah untuk mengonfigurasi variabel lingkungan dan flag untuk proyek Anda.

Anda dapat menambahkan baris ini ke Makefile Anda jika Anda perlu mengatur GOOS Dan GOARCH variabel untuk membangun proyek Anda untuk sistem operasi atau arsitektur tertentu.

 

GOCMD=go
GOBUILD=$(GOCMD) build
GOTEST=$(GOCMD) test
GOCLEAN=$(GOCMD) clean
BINARY_NAME=app
TEST_FLAGS=-v
GOOS=linux
GOARCH=amd64

build:
    $(GOBUILD) -o $(BINARY_NAME) .
test:
    $(GOTEST) $(TEST_FLAGS) ./...
clean:
    $(GOCLEAN)
    rm -f $(BINARY_NAME)
 

Di Makefile yang diperbarui, ada dua variabel baru untuk GOOS Dan GOARCH variabel lingkungan yang memungkinkan Anda menentukan sistem operasi dan arsitektur target untuk build Anda (dalam hal ini, GOOS variabel diatur ke linux Dan GOARCH ke amd64 untuk membangun proyek untuk Linux pada arsitektur x86-64).

Ingatlah untuk mengadaptasi variabel-variabel ini berdasarkan kebutuhan spesifik proyek Anda.

Anda dapat merujuk ke Pergi dokumentasi untuk daftar nilai yang didukung untuk GOOS Dan GOARCH jika Anda perlu membangun untuk platform yang berbeda.

Bangun Otomasi Dengan Makefiles

Makefile juga berguna untuk mengkompilasi kode, membuat dokumentasi, dan mengelola dependensi.

Dengan Makefiles, Anda dapat mengotomatiskan waktu kompilasi, menghemat waktu dan tenaga Anda.

Inilah Makefile yang mengkompilasi program Go:

 
GOCMD = go
GOBUILD = $(GOCMD) build
BINARY_NAME = myprogram

all: build

build:
    $(GOBUILD) -o $(BINARY_NAME)

clean:
    rm -f $(BINARY_NAME)
 

Makefile mendefinisikan variabel seperti GOCMD (perintah Go) dan GOBUILD (perintah bangun). Itu membangun target memanggil pergi membangun perintah untuk mengkompilasi program Go kami dan menghasilkan biner dengan nama yang ditentukan (myprogram pada kasus ini). Itu membersihkan target menghapus biner yang dihasilkan dari proyek.

Anda dapat menggunakan Makefiles untuk mengotomatiskan penginstalan dependensi dan terus memperbarui dependensi eksternal proyek Anda.

 
GOCMD = go
GOBUILD = $(GOCMD) build
GOGET = $(GOCMD) get
BINARY_NAME = myprogram

all: build

build:
    $(GOBUILD) -o $(BINARY_NAME)

deps:
    $(GOGET) -u

clean:
    rm -f $(BINARY_NAME)
 

Makefile memiliki dep sasaran yang menggunakan pergi dapatkan perintah untuk menginstal atau memperbarui dependensi proyek. Anda bisa lari buat dep untuk menginstal dependensi proyek Anda.

Makefiles dapat mengotomatiskan pembuatan dokumentasi dan menyempurnakan dokumen Anda sebagai proses kode.

Inilah cara Anda dapat membuat dokumentasi secara otomatis untuk proyek Go Anda dengan alat godoc dan Makefile:

 
GODOC = godoc
DOCS_DIR = docs

all: docs

docs:
    $(GODOC) -html -dir . > $(DOCS_DIR)/index.html

clean:
    rm -rf $(DOCS_DIR)
 

Di Makefile, file dokumen target memanggil godoc perintah dengan -html tandai untuk menghasilkan dokumentasi HTML untuk kode go Anda dan menyimpan dokumentasi tersebut ke dokumen direktori.

Anda akan menjalankan membuat dokumen perintah untuk menghasilkan dokumentasi terbaru untuk proyek Go Anda.

Makefile Berguna untuk Bekerja Dengan Sistem Operasi Berbasis Unix

Dengan memanfaatkan fleksibilitas Makefiles, Anda dapat menentukan perintah build kustom dan menjalankan tugas kompleks dalam hitungan menit. Makefile menghemat waktu dan memastikan konsistensi dan reproduktifitas di seluruh lingkungan build.

Keuntungan lain dari Makefiles adalah kompatibilitasnya dengan sistem berbasis Unix. Make adalah utilitas yang didukung secara luas pada sistem operasi berbasis Unix, termasuk Linux dan macOS, menjadikannya alat yang portabel dan andal untuk pengembang.