Dasar-dasar Go

Pengantar Bahasa Go

Go , juga dikenal sebagai Golang, adalah bahasa pemrograman sumber terbuka yang dikembangkan oleh insinyur Google Robert Griesemer, Rob Pike, dan Ken Thompson. Itu dirancang agar sederhana, efisien, dan dapat diandalkan. Go cocok untuk pengembangan aplikasi modern, terutama di bidang sistem infrastruktur sisi server dan backend. Dengan sintaks langsungnya, dukungan bawaan untuk konkurensi, dan kinerja luar biasa, Go telah menjadi pilihan populer di kalangan pengembang untuk membuat aplikasi web, layanan mikro, dan sistem terdistribusi.

Ekosistem Go telah berkembang pesat sejak dirilis pada tahun 2009, menawarkan berbagai pustaka dan alat untuk dimanfaatkan oleh pengembang. Perusahaan seperti Dropbox, Uber, dan Docker telah memilih Go untuk sistem backend dasar mereka, menyoroti lebih jauh pentingnya dan relevansinya dalam lingkungan teknologi saat ini.

Artikel ini bertujuan untuk memberi Anda dasar yang kuat dalam Go dan sintaksnya, berfokus pada fitur bahasa utama untuk memulai perjalanan Anda dengan pemrograman Go.

Menginstal dan Menyiapkan Go

Sebelum Anda mulai bekerja dengan Go, Anda harus menginstal bahasa di komputer Anda. Ikuti langkah-langkah ini untuk memulai:

1. Kunjungi situs resmi Go dan unduh file instalasi yang sesuai untuk sistem operasi Anda.
2. Buka file yang diunduh dan ikuti petunjuk penginstalan yang disediakan oleh penginstal.
3. Tetapkan variabel lingkungan PATH untuk memasukkan direktori instalasi Go. Ini akan memastikan bahwa perintah Go tersedia dari baris perintah. Pada sistem Unix, Anda biasanya dapat menambahkan baris berikut ke file .bashrc atau .profile Anda:
   export PATH=$PATH:/usr/local/go/bin
4. Mulai ulang terminal atau prompt perintah Anda untuk menerapkan perubahan.
5. Konfirmasikan bahwa Go diinstal dengan benar dengan menjalankan perintah berikut di terminal Anda:
   go version
   Jika penginstalan berhasil, versi Go yang diinstal di komputer Anda akan ditampilkan di output.

Sekarang setelah Go terinstal di komputer Anda, saatnya menyelami dasar-dasar bahasa.

Memahami Sintaks Go dan Tipe Data

Sintaks Go dirancang agar sederhana dan mudah dibaca. Di sini, kami akan membahas beberapa elemen bahasa penting, termasuk paket, impor, variabel, dan tipe data dasar.

Paket dan Impor

Program Go diatur ke dalam packages , yang membantu memodulasi dan mengelola kode. Sebuah paket pada dasarnya adalah sebuah direktori yang berisi satu atau lebih file sumber Go. Baris pertama dari setiap file Go harus mendeklarasikan paket miliknya:

 package main

Pada contoh di atas, file sumber milik paket "utama". Blok kode yang mengikuti deklarasi paket biasanya terdiri dari pernyataan import yang menyertakan paket lain yang diperlukan untuk program Anda:

 import ( "fmt" "math" )

Pernyataan import menentukan paket yang akan diimpor ke file saat ini, memungkinkan Anda untuk mengakses fitur yang diekspor, seperti fungsi dan variabel.

Variabel dan Konstanta

Variabel di Go dapat dideklarasikan menggunakan kata kunci var , diikuti dengan nama variabel, tipe, dan nilai awal opsional:

 var x int = 10

Jika nilai awal diberikan, Go dapat menyimpulkan tipenya, memungkinkan Anda untuk menghilangkan deklarasi tipe:

 var x = 10 // x is an int

Anda juga dapat menggunakan sintaks pendek deklarasi variabel Go, yang secara otomatis menyimpulkan tipe dan memberikan nilai awal:

 x := 10 // x is an int

Konstanta dapat dideklarasikan menggunakan kata kunci const . Nilainya harus diketahui pada waktu kompilasi dan tidak dapat diubah selama eksekusi program:

 const PI = 3.14159

Tipe Data Dasar

Go memiliki beberapa tipe data fundamental, antara lain:

• Bilangan bulat: Bilangan bulat yang ditandatangani dapat dideklarasikan menggunakan int , int8 , int16 , int32 , atau int64 . Unsigned integer dapat didefinisikan dengan uint , uint8 , uint16 , uint32 , atau uint64 .
• Nomor Floating-Point: Ini dapat didefinisikan menggunakan float32 atau float64 .
• Bilangan Kompleks: Bilangan kompleks dideklarasikan menggunakan complex64 atau complex128 .
• Boolean: Boolean diwakili oleh tipe data bool dan dapat memiliki nilai true atau false .
• String: String Go adalah rangkaian karakter yang disandikan UTF-8. Mereka tidak dapat diubah, dan panjangnya ditentukan saat runtime.

Selain itu, Go mendukung tipe data gabungan, seperti:

• Array: Urutan elemen dengan panjang tetap dari tipe yang sama.
• Irisan: Urutan panjang dinamis elemen dari jenis yang sama.
• Peta: Koleksi pasangan kunci-nilai yang tidak diurutkan, di mana kunci dan nilai dapat memiliki jenis yang ditentukan.

Saat Anda terus mempelajari Go, Anda akan dapat menggabungkan tipe dan struktur data dasar ini untuk membangun aplikasi yang lebih kompleks dan serbaguna.

Fungsi dan Metode di Go

Fungsi adalah salah satu blok bangunan penting dari bahasa pemrograman apa pun, dan Go tidak terkecuali. Fungsi dalam Go didefinisikan menggunakan kata kunci func , diikuti dengan nama fungsi, parameter input, tipe kembalian, dan isi fungsi. Fungsi di Go dapat mengembalikan banyak nilai, membuatnya lebih mudah untuk menangani operasi kompleks dan pemeriksaan kesalahan.

Berikut adalah contoh fungsi Go sederhana:

 package main import ( "fmt" ) func add(a int, b int) int { return a + b } func main() { result1 := add(5, 7) fmt.Println("The sum is:", result1) }

Dalam contoh ini, kami mendefinisikan fungsi add sederhana yang mengambil dua parameter bilangan bulat dan mengembalikan jumlahnya. Fungsi tersebut kemudian dipanggil dari fungsi main , dan hasilnya dicetak.

Try AppMaster no-code today!

Platform can build any web, mobile or backend application 10x faster and 3x cheaper

Start Free

Metode di Go

Metode di Go mirip dengan fungsi, tetapi diasosiasikan dengan tipe penerima tertentu, dan dipanggil pada turunan dari tipe penerima. Ini memungkinkan untuk menambahkan perilaku ke tipe yang sudah ada, mirip dengan bagaimana bahasa pemrograman berorientasi objek mendefinisikan metode pada kelas. Ini contohnya:

 package main import ( "fmt" ) type Circle struct { radius float64 } func (c Circle) area() float64 { return 3.14159 * c.radius * c.radius } func main() { myCircle := Circle{radius: 5} circleArea := myCircle.area() fmt.Printf("The area of the circle is: %.2f\n", circleArea) }

Dalam contoh ini, kami mendefinisikan struktur Circle dengan bidang radius . Metode bernama area kemudian ditentukan untuk tipe Circle . Metode ini menghitung luas lingkaran menggunakan radius dan mengembalikan hasilnya sebagai nilai float64.

Struktur Kontrol di Go

Struktur kontrol adalah dasar dari setiap bahasa pemrograman karena mendikte aliran program. Go menawarkan beberapa struktur kontrol untuk percabangan bersyarat, perulangan, dan beberapa pemeriksaan kondisi atau operasi komunikasi.

Jika Pernyataan

Di Go, percabangan bersyarat biasanya dilakukan menggunakan pernyataan if . Pernyataan ini mengevaluasi ekspresi boolean dan, jika benar, jalankan blok kode yang mengikuti ekspresi tersebut. Berikut contohnya:

 package main import ( "fmt" ) func main() { number := 42 if number%2 == 0 { fmt.Println("The number is even.") } else { fmt.Println("The number is odd.") } }

Dalam contoh ini, kami memeriksa apakah suatu bilangan genap atau ganjil menggunakan operator modulo dan pernyataan if .

Untuk Loop

Go hanya memiliki satu jenis perulangan: perulangan for . Ini dapat digunakan untuk semua jenis skenario perulangan: iterasi tetap, loop tak terbatas, dan loop "sementara". Berikut contohnya:

 package main import ( "fmt" ) func main() { for i := 1; i <= 5; i++ { fmt.Println("Iteration:", i) } }

Dalam contoh ini, kami menggunakan perulangan for dengan penghitung untuk mengulangi lima kali dan mencetak nomor iterasi saat ini.

Beralih dan Pilih Pernyataan

Go menyediakan pernyataan switch untuk beberapa pemeriksaan kondisi dan pernyataan select untuk operasi komunikasi. Berikut adalah contoh pernyataan switch :

 package main import ( "fmt" ) func main() { grade := "B" switch grade { case "A": fmt.Println("Excellent!") case "B": fmt.Println("Good") case "C": fmt.Println("Fair") case "D": fmt.Println("Poor") default: fmt.Println("Invalid grade") } }

Dalam contoh ini, kami menggunakan pernyataan switch untuk memeriksa nilai masukan dan mencetak pernyataan kinerja yang sesuai. Tidak seperti bahasa lain, Go tidak memerlukan pernyataan break di akhir setiap blok case, karena ia keluar dari pernyataan switch setelah menjalankan case yang cocok.

Konkurensi di Go

Salah satu fitur Go yang paling canggih adalah dukungan bawaannya untuk konkurensi menggunakan Goroutine dan Saluran. Konkurensi memungkinkan beberapa utas eksekusi berjalan secara bersamaan, memungkinkan kinerja dan daya tanggap yang lebih besar dalam aplikasi.

Goroutine

Goroutine adalah eksekusi fungsi yang ringan dan serentak di Go. Untuk membuat Goroutine, cukup tambahkan kata kunci go ke pemanggilan fungsi. Fungsi mulai dijalankan bersamaan dengan program lainnya, berbagi ruang alamat yang sama. Berikut contohnya:

 package main import ( "fmt" "time" ) func display(message string) { for i := 0; i < 5; i++ { fmt.Println(message) time.Sleep(1 * time.Second) } } func main() { go display("Hello") go display("World") // Let Goroutines finish before exiting time.Sleep(5 * time.Second) }

Dalam contoh ini, kami membuat dua Goroutine yang menampilkan pesan dan menjeda selama satu detik sebelum mengulanginya. Fungsi utama menunggu selama lima detik untuk memastikan Goroutine selesai sebelum keluar dari program.

Saluran

Saluran adalah sarana komunikasi antara Goroutine. Mereka mengizinkan Goroutine untuk mengirim dan menerima nilai dengan cara yang aman. Berikut contohnya:

 package main import ( "fmt" ) func producer(numbers chan<- int) { for i := 1; i <= 5; i++ { fmt.Println("Produced:", i) numbers <- i } close(numbers) // Close the channel when done } func consumer(numbers <-chan int) { for number := range numbers { fmt.Println("Consumed:", number) } } func main() { numbers := make(chan int) go producer(numbers) go consumer(numbers) // Let the Goroutines finish time.Sleep(1 * time.Second) }

Dalam contoh ini, kami membuat Goroutine producer yang menghasilkan angka dan mengirimkannya ke saluran, dan Goroutine consumer yang memproses nomor yang diterima dari saluran. Dengan menggunakan saluran, kami memastikan komunikasi yang aman antara Goroutine.

Concurrency di Go, menggunakan Goroutine dan Channels, menyederhanakan pengembangan aplikasi bersamaan, menjadikannya lebih efisien, andal, dan mudah dipahami.

Praktik Terbaik untuk Menulis Kode Go

Menulis kode Go yang bersih, dapat dipelihara, dan efisien sangat penting untuk mengembangkan aplikasi yang kuat dan memastikan kesuksesan jangka panjang. Berikut beberapa praktik terbaik yang harus Anda ikuti saat bekerja dengan Go:

Try AppMaster no-code today!

Platform can build any web, mobile or backend application 10x faster and 3x cheaper

Start Free

Konvensi Penamaan yang Tepat

Konvensi penamaan memainkan peran penting dalam membuat kode Go Anda mudah dipahami dan dipelihara. Ikuti panduan ini untuk memberi nama di Go:

• Nama paket harus huruf kecil, pendek, dan ringkas. Hindari penggunaan garis bawah atau nama huruf campuran.
• Nama variabel, fungsi, dan metode harus menggunakan huruf besar, dengan huruf pertama setiap kata dikapitalisasi, kecuali untuk kata pertama.
• Pengidentifikasi yang diekspor , seperti fungsi, metode, dan variabel yang dapat diakses dari paket lain, harus dimulai dengan huruf kapital.
• Pengidentifikasi yang tidak diekspor , yang terbatas pada paket tempat mereka didefinisikan, harus dimulai dengan huruf kecil.

Pemformatan yang Tepat

Mengikuti format yang konsisten di seluruh kode Go membuatnya lebih mudah dibaca dan dipahami. Komunitas Go telah mengembangkan alat bernama gofmt yang secara otomatis memformat kode Anda sesuai dengan panduan yang disarankan. Gunakan alat ini untuk memastikan kode Anda mematuhi gaya yang konsisten.

Tulis Fungsi Singkat dan Terfokus

Pastikan fungsi dan metode Anda singkat dan terfokus pada satu tujuan. Ini meningkatkan keterbacaan, pemeliharaan, dan menyederhanakan pengujian. Alih-alih menulis satu fungsi dengan banyak tanggung jawab berbeda, pisahkan menjadi fungsi yang lebih kecil dan lebih spesifik. Pendekatan ini juga membantu dalam menggunakan kembali kode di berbagai bagian aplikasi Anda.

Penanganan Error yang Ketat

Penanganan kesalahan adalah aspek inti dari pemrograman Go. Go mendorong Anda untuk menangani kesalahan secara eksplisit, daripada mengandalkan pengecualian. Ketika suatu fungsi mengembalikan kesalahan, selalu periksa dan tangani dengan tepat. Manfaatkan pola idiomatis if err != nil untuk memastikan program Anda berjalan dengan benar jika ada kesalahan. Selain itu, berikan konteks dalam pesan kesalahan Anda untuk membantu Anda dan pengembang lain mengidentifikasi dan mendiagnosis masalah dengan lebih mudah.

Tulis Tes Unit Komprehensif

Tes unit penulisan sangat penting untuk memastikan kebenaran dan keandalan kode Go Anda. Go memiliki dukungan bawaan untuk pengujian melalui paket pengujiannya. Tulis pengujian untuk masing-masing fungsi, metode, dan paket untuk memvalidasi perilakunya dan menangkap potensi masalah saat Anda membuat perubahan pada kode. Investasikan waktu untuk menulis pengujian yang dapat dipelihara dan menyeluruh untuk mencegah bug dan meningkatkan kepercayaan pada kode Anda.

Gunakan Paket dan Perpustakaan Go dengan Bijak

Go memiliki ekosistem yang kuat dengan banyak library dan package, baik di library standar maupun dari komunitas yang lebih luas. Meskipun menggunakan pustaka dapat menghemat waktu, berhati-hatilah saat memilih dependensi eksternal. Selalu pilih perpustakaan yang bereputasi baik dan terdokumentasi dengan baik dan evaluasi beberapa opsi sebelum membuat keputusan. Selain itu, jaga agar daftar ketergantungan Anda tetap dapat dikelola dan dipantau untuk potensi masalah keamanan dan kinerja.

Dokumentasikan Kode Anda

Tulis komentar yang jelas dan ringkas dan dokumentasikan kode Anda menggunakan konvensi dokumen Go. Mendokumentasikan kode Anda dengan komentar, penjelasan, dan contoh yang memadai sangat penting untuk pemeliharaan jangka panjang dan kerja sama tim.

Kasus Penggunaan dan Pustaka Populer untuk Go

Go adalah bahasa pemrograman serbaguna dengan banyak kasus penggunaan. Beberapa area aplikasi paling populer untuk Go antara lain:

• Pemrograman sisi server dan layanan web
• Jaringan dan sistem terdistribusi
• arsitektur layanan mikro
• Alat DevOps dan CLI

Berikut adalah daftar beberapa pustaka dan kerangka kerja populer di ekosistem Go yang melayani kebutuhan pengembangan umum:

Kerangka Kerja dan Pustaka Web

• Gin: Kerangka kerja web yang cepat, sederhana, dan ringan dengan API mirip martini.
• Echo: Framework web berperforma tinggi, dapat diperluas, dan minimalis untuk Go.
• Bersenang-senang: Kerangka web full-stack yang tidak memerlukan konfigurasi atau kode boilerplate untuk memulai.

API dan Alat Protokol

• gRPC: Kerangka kerja RPC universal open-source berkinerja tinggi.
• Gorilla Mux: Perute URL dan pustaka pengirim yang andal untuk membuat aplikasi web dan API Go.

Driver dan Pembantu Database

• GORM: Pustaka ORM yang luar biasa untuk Go yang mendukung berbagai sistem basis data seperti PostgreSQL , MySQL , SQLite, dan banyak lagi.
• sqlx: Perpanjangan dari paket database/sql standar yang menyederhanakan dan meningkatkan operasi database sambil mempertahankan kompatibilitas dengan paket standar.

Selain pustaka ini, pustaka standar Go menawarkan banyak paket berguna untuk bekerja dengan berbagai fungsi, seperti jaringan, I/O, struktur data, algoritme, dan lainnya.

Perlu diperhatikan bahwa mempelajari bahasa pemrograman Go dan menggunakan pustaka/API populer hanyalah salah satu aspek dalam membangun aplikasi yang sukses. Untuk benar-benar mempercepat proses pengembangan Anda dan menghilangkan hutang teknis, Anda dapat mempertimbangkan untuk mencoba AppMaster   — platform tanpa kode yang memungkinkan Anda membuat aplikasi backend, web, dan seluler menggunakan antarmuka visual sambil membuat kode sumber secara otomatis tanpa utang teknis. Dengan platform AppMaster, aplikasi Go Anda dapat dikembangkan hingga 10x lebih cepat dan 3x lebih hemat biaya, mencakup berbagai fungsi dan kasus penggunaan.