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 kompleks.

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

Memahami Makefile

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 cangkang 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
 pergi membangun -o myapp main.go utils.go
membersihkan:
 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.

membuat bangunan

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.

sentuh Makefile

Makefile Anda tidak boleh 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:

# Makefile
# Variabel
GOCMD = pergi
GOBUILD=$(GOCMD) membangun
MENDAPATKAN=$(GOCMD) tes
GOCLEAN=$(GOCMD) membersihkan
# Target
membangun:
$(GOBUILD) -o aplikasi.
tes:
$(TERBAIK) ./...
membersihkan:
$(GOCLEAN)
 aplikasi rm -f

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:

# Makefile
# Variabel
GOCMD = pergi
GOBUILD=$(GOCMD) membangun
MENDAPATKAN=$(GOCMD) tes
GOCLEAN=$(GOCMD) membersihkan
BINARY_NAME=aplikasi
TEST_FLAGS=-v
# Target
membangun:
$(GOBUILD) -Hai $(BINARY_NAME) .
tes:
$(TERBAIK)$(TEST_FLAGS) ./...
membersihkan:
$(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.

# Makefile
# Variabel
GOCMD = pergi
GOBUILD=$(GOCMD) membangun
MENDAPATKAN=$(GOCMD) tes
GOCLEAN=$(GOCMD) membersihkan
BINARY_NAME=aplikasi
TEST_FLAGS=-v
GOOS=linux
GOARCH=amd64
# Target
membangun:
$(GOBUILD) -Hai $(BINARY_NAME) .
tes:
$(TERBAIK)$(TEST_FLAGS) ./...
membersihkan:
$(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:

# Tentukan variabel
GOCMD = pergi
GOBUILD = $(GOCMD) membangun
BINARY_NAME = program saya
# Target bawaan
semua: membangun
# Bangun target
membangun:
$(GOBUILD) -Hai $(BINARY_NAME)
# Sasaran bersih
membersihkan:
 rm -f $(BINARY_NAME)

Makefile mendefinisikan variabel seperti GOCMD (perintah Go) dan GOBUILD (perintah membangun). 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.

# Tentukan variabel
GOCMD = pergi
GOBUILD = $(GOCMD) membangun
GOGET = $(GOCMD) mendapatkan
BINARY_NAME = program saya
# Target bawaan
semua: membangun
# Bangun target
membangun:
$(GOBUILD) -Hai $(BINARY_NAME)
# Instal dependensi
ketergantungan:
$(GOGET) -u
# Sasaran bersih
membersihkan:
 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 meningkatkan docs sebagai proses kode.

Inilah cara Anda bisa buat dokumentasi secara otomatis untuk proyek Go Anda dengan alat godoc dan Makefile:

# Tentukan variabel
GODOC = godok
DOCS_DIR = dokumen
# Target bawaan
semua: dok
# Hasilkan dokumentasi
dokumen:
$(GODOC) -html -dir. > $(DOCS_DIR)/index.html
# Sasaran bersih
membersihkan:
 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 beberapa 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.