Go (sering disebut Golang) adalah bahasa pemrograman open source yang dikembangkan oleh Google pada tahun 2009. Bahasa ini dirancang untuk membangun aplikasi berskala besar dengan performa tinggi, sintaks yang sederhana, dan dukungan bawaan untuk concurrency. Berkat kemudahan dan kecepatannya, Go menjadi tulang punggung banyak proyek besar seperti Docker, Kubernetes, dan berbagai layanan cloud modern. Dalam tutorial ini, kamu akan belajar Go dari nol — mulai dari instalasi, sintaks dasar, hingga membangun HTTP server dan menjalankan kode secara konkuren dengan goroutine.
Apa Itu Go (Golang)?
Go adalah bahasa pemrograman compiled dan statically typed yang memadukan kecepatan eksekusi bahasa seperti C dengan kemudahan penulisan bahasa modern. Kode Go dikompilasi menjadi satu binary mandiri, sehingga sangat mudah di-deploy — kamu cukup menyalin satu file tanpa perlu menginstal runtime tambahan di server.
Beberapa keunggulan utama Go yang membuatnya populer di kalangan developer:
- Sintaks sederhana — hanya ada 25 kata kunci, mudah dipelajari bahkan untuk pemula.
- Concurrency bawaan — goroutine dan channel membuat pemrograman konkuren menjadi ringan dan aman.
- Kompilasi cepat — waktu build sangat singkat bahkan untuk proyek besar.
- Toolchain lengkap — formatter (
gofmt), dependency manager (go mod), dan test framework bawaan. - Ekosistem cloud-native — mayoritas infrastruktur modern ditulis dengan Go.
Jika kamu sudah familiar dengan async/await dan asyncio di Python, kamu akan cepat memahami konsep concurrency di Go. Model goroutine-nya lebih sederhana dan tidak membutuhkan keyword async/await — cukup awali pemanggilan fungsi dengan kata kunci go.
Instalasi Go
Langkah pertama adalah menginstal Go di sistem kamu. Kunjungi go.dev/dl untuk mengunduh installer sesuai sistem operasi, atau gunakan perintah berikut di Linux/macOS:
# Linux (Ubuntu/Debian)
sudo apt update
sudo apt install golang-go
# macOS (dengan Homebrew)
brew install go
# Verifikasi instalasi
go versionSetelah terinstal, pastikan perintah go version menampilkan versi Go (misalnya go1.22 atau lebih baru). Untuk Windows, unduh installer .msi dari situs resmi dan ikuti wizard-nya.
Program Pertama: Hello World
Buat direktori proyek baru dan inisialisasi modul Go. Modul adalah cara Go mengelola dependensi proyek:
mkdir belajar-go
cd belajar-go
go mod init bengkelkode/helloSelanjutnya buat file main.go dengan isi berikut:
package main
import "fmt"
func main() {
fmt.Println("Halo, BengkelKode!")
}Jalankan program dengan go run main.go. Kamu akan melihat output Halo, BengkelKode! di terminal. Setiap program Go dimulai dari fungsi main di dalam package main. Import fmt menyediakan fungsi untuk format dan mencetak output ke layar.
Variabel dan Tipe Data Dasar
Go memiliki beberapa cara untuk mendeklarasikan variabel. Kata kunci var untuk deklarasi eksplisit, dan operator := untuk deklarasi singkat dengan type inference:
package main
import "fmt"
func main() {
var nama string = "Budi"
var umur int = 25
tinggi := 170.5 // type inference: float64
const pi = 3.14 // konstanta tidak bisa diubah
fmt.Println(nama, umur, tinggi, pi)
}Tipe data dasar di Go meliputi int, float64, string, bool, serta tipe komposit seperti array, slice, dan map. Perhatikan bahwa Go adalah bahasa statically typed, jadi tipe variabel ditentukan saat kompilasi — hal ini membantu menangkap bug lebih awal.
Fungsi dan Multiple Return Values
Salah satu fitur khas Go adalah kemampuan fungsi mengembalikan lebih dari satu nilai. Ini sangat berguna untuk mengembalikan hasil sekaligus status error — pola yang umum di seluruh ekosistem Go:
package main
import (
"fmt"
"errors"
)
func tambah(a, b int) int {
return a + b
}
func bagi(a, b float64) (float64, error) {
if b == 0 {
return 0, errors.New("tidak bisa membagi dengan nol")
}
return a / b, nil
}
func main() {
fmt.Println("10 + 5 =", tambah(10, 5))
hasil, err := bagi(10, 0)
if err != nil {
fmt.Println("Error:", err)
return
}
fmt.Println("Hasil:", hasil)
}Struct dan Method
Go bukan bahasa berorientasi objek murni seperti Java — tidak ada class. Sebagai gantinya, kamu menggunakan struct untuk mengelompokkan data, lalu menempelkan method pada struct tersebut:
package main
import "fmt"
type Mahasiswa struct {
Nama string
Umur int
}
func (m Mahasiswa) Sapa() string {
return fmt.Sprintf("Halo, saya %s, umur %d tahun", m.Nama, m.Umur)
}
func (m *Mahasiswa) UlangTahun() {
m.Umur++
}
func main() {
mhs := Mahasiswa{Nama: "Budi", Umur: 20}
fmt.Println(mhs.Sapa())
mhs.UlangTahun() // pointer receiver, mengubah data asli
fmt.Println(mhs.Sapa())
}Interface
Interface di Go mendefinisikan sekumpulan method. Tipe apa pun yang mengimplementasikan method tersebut secara otomatis memenuhi interface — tanpa deklarasi implements secara eksplisit:
package main
import "fmt"
type Bentuk interface {
Luas() float64
}
type Persegi struct {
Sisi float64
}
func (p Persegi) Luas() float64 {
return p.Sisi * p.Sisi
}
type Lingkaran struct {
Radius float64
}
func (l Lingkaran) Luas() float64 {
return 3.14 * l.Radius * l.Radius
}
func cetakLuas(b Bentuk) {
fmt.Printf("Luas: %.2f\n", b.Luas())
}
func main() {
cetakLuas(Persegi{Sisi: 4})
cetakLuas(Lingkaran{Radius: 3})
}Error Handling
Go tidak menggunakan try/catch. Sebagai gantinya, error diperlakukan sebagai nilai biasa yang dikembalikan dari fungsi dan dicek secara eksplisit. Pola standarnya adalah memeriksa apakah err != nil:
file, err := os.Open("data.txt")
if err != nil {
log.Fatal("Gagal membuka file:", err)
}
defer file.Close()
// ... lanjutkan membaca file ...Kata kunci defer menjadwalkan sebuah pemanggilan fungsi untuk dijalankan tepat sebelum fungsi pembungkusnya selesai. Ini sangat berguna untuk memastikan resource seperti file atau koneksi database selalu ditutup dengan bersih — letakkan defer file.Close() tepat setelah file berhasil dibuka.
Concurrency dengan Goroutine dan Channel
Keunggulan terbesar Go adalah concurrency. Goroutine adalah fungsi yang berjalan secara konkuren dan sangat ringan — kamu bisa menjalankan ribuan goroutine sekaligus. Cukup awali pemanggilan fungsi dengan kata kunci go:
package main
import "fmt"
func cetakAngka(ch chan int) {
for i := 1; i <= 5; i++ {
ch <- i // kirim nilai ke channel
}
close(ch) // tutup channel setelah selesai
}
func main() {
ch := make(chan int)
go cetakAngka(ch) // jalankan sebagai goroutine
for n := range ch { // terima nilai sampai channel ditutup
fmt.Println(n)
}
}Channel adalah jalur komunikasi antar-goroutine yang aman digunakan secara bersamaan. Pola "jangan berkomunikasi dengan berbagi memori; berbagilah memori dengan berkomunikasi" adalah filosofi utama concurrency di Go. Berbeda dengan threading dan multiprocessing di Python, goroutine jauh lebih hemat resource karena dijadwalkan oleh Go runtime, bukan sistem operasi.
Selalu tutup channel hanya dari sisi pengirim (sender), bukan dari penerima (receiver). Mengirim data ke channel yang sudah ditutup akan menyebabkan panic. Jika ragu apakah semua pengirim sudah selesai, gunakan sync.WaitGroup untuk menyinkronkan goroutine.
Membangun HTTP Server Sederhana
Sekarang mari gabungkan semua yang sudah dipelajari dengan membangun HTTP server sederhana menggunakan paket standar net/http — tanpa framework eksternal:
package main
import (
"fmt"
"net/http"
)
func handler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Halo, %s!", r.URL.Path[1:])
}
func main() {
http.HandleFunc("/", handler)
fmt.Println("Server berjalan di http://localhost:8080")
http.ListenAndServe(":8080", nil)
}Jalankan dengan go run main.go, lalu buka http://localhost:8080/bengkelkode di browser. Kamu akan melihat teks Halo, bengkelkode!. Jika kamu lebih nyaman dengan Python, kamu bisa membandingkannya dengan cara membuat REST API dengan FastAPI — Go unggul dalam hal performa dan kemudahan deployment karena menghasilkan satu binary mandiri.
Kesimpulan
Kamu baru saja mempelajari fondasi bahasa Go: instalasi, sintaks dasar, fungsi dengan multiple return values, struct dan method, interface, error handling, serta concurrency dengan goroutine dan channel. Dengan pemahaman ini, kamu sudah siap membangun aplikasi backend yang cepat dan scalable. Langkah selanjutnya, cobalah membangun REST API lengkap dengan Go, atau eksplorasi ekosistem cloud-native seperti Docker dan Kubernetes yang semuanya dibangun dengan Go. Selamat ngoding!
