Belajar Struct Golang: Pengganti Class untuk OOP di Go

Ringkasan

• Memahami mengapa Go tidak menggunakan class dan bagaimana struct menjadi solusi untuk pengelompokan data.
• Cara menambahkan perilaku pada data menggunakan Value Receiver dan Pointer Receiver.
• Implementasi Composition sebagai alternatif Inheritance untuk membangun arsitektur kode yang fleksibel dan efisien.
• Tips praktis penggunaan struct untuk menangani JSON, Database, dan API dalam pengembangan aplikasi nyata.

Halo para developer! Kalau kamu baru saja pindah dari bahasa pemrograman seperti Java, C#, atau Python, mungkin kamu akan merasa ada yang "hilang" saat pertama kali melihat sintaks Go (Golang). Satu hal yang paling mencolok adalah: Go tidak punya kata kunci class.

Bagi banyak orang, class adalah jantung dari Pemrograman Berorientasi Objek (OOP). Lantas, bagaimana cara kita membuat objek, mengelola state, dan mendefinisikan perilaku jika tidak ada class? Jawabannya adalah Struct. Di artikel kali ini, kita akan bedah tuntas bagaimana struct bekerja dan mengapa pendekatan "tanpa class" ini justru membuat Go menjadi bahasa yang sangat efisien dan dicintai banyak perusahaan teknologi besar di tahun 2025.

Apa Itu Struct di Golang?

Secara sederhana, struct (singkatan dari structure) adalah tipe data kustom yang memungkinkan kita mengelompokkan berbagai field dengan tipe data yang berbeda ke dalam satu wadah. Jika array atau slice hanya bisa menyimpan data dengan tipe yang sama (homogen), struct memungkinkan kita menggabungkan string, int, bool, bahkan struct lain ke dalam satu unit yang bermakna (heterogen).

Bayangkan kamu sedang membangun sistem manajemen pengguna. Daripada membuat variabel terpisah seperti userName1, userEmail1, dan userAge1, kamu bisa membungkus semuanya dalam satu struct bernama User. Ini membuat data lebih terorganisir, mudah divalidasi, dan sangat efisien saat dipindahkan antar fungsi dalam aplikasi.

Deklarasi dan Inisialisasi Struct

Mari kita lihat contoh praktis cara mendeklarasikan struct. Perhatikan kode berikut:

type User struct {
    ID       int
    Name     string
    Email    string
    IsActive bool
}

Setelah mendefinisikan tipe User, kita bisa membuat instance atau objek dari struct tersebut dengan beberapa cara yang berbeda, tergantung pada kebutuhan fleksibilitas dan keamanan kode:

1. Named Fields (Sangat Direkomendasikan)

Kita menyebutkan nama field-nya secara eksplisit. Cara ini adalah standar industri karena lebih aman dan mudah dibaca oleh developer lain. Jika ada penambahan field di masa depan, kode ini tidak akan rusak.

user1 := User{
    ID:       1,
    Name:     "Budi",
    Email:    "[email protected]",
    IsActive: true,
}

2. Positional Fields

Mengisi data berdasarkan urutan deklarasi. Cara ini sangat berisiko; jika kamu menambah satu field baru di tengah deklarasi struct, semua kode yang menggunakan positional fields akan error atau menyimpan data di field yang salah.

user2 := User{2, "Siti", "[email protected]", true}

3. Inisialisasi Kosong (Zero Value)

Kamu juga bisa membuat struct kosong yang akan terisi dengan zero value (0 untuk int, "" untuk string, false untuk bool).

var user3 User
user3.Name = "Andi"

Konsep Visibilitas: Publik vs Privat

Salah satu perbedaan fundamental Go dengan Java atau C# adalah tidak adanya keyword public, private, atau protected. Di Go, visibilitas ditentukan oleh huruf pertama nama field atau method.

• Exported (Publik): Jika diawali huruf kapital (contoh: Name), maka field tersebut bisa diakses dari package lain.
• Unexported (Privat): Jika diawali huruf kecil (contoh: email), maka field tersebut hanya bisa diakses di dalam package yang sama.

Konsep ini memaksa developer untuk berpikir lebih sederhana tentang enkapsulasi tanpa harus menulis banyak boilerplate code.

Menambahkan Perilaku dengan Method

Struct sendiri hanyalah kumpulan data (state). Untuk memberikan "nyawa" atau perilaku pada data tersebut, Go menggunakan Method. Method adalah fungsi yang memiliki receiver, yaitu variabel yang mengikat fungsi tersebut ke tipe data tertentu.

1. Value Receiver

Value receiver digunakan ketika method hanya perlu membaca data tanpa mengubah isinya. Go akan membuat salinan (copy) dari struct tersebut saat method dipanggil. Ini aman untuk data yang tidak boleh berubah (immutable).

func (u User) GetProfile() string {
    return "User: " + u.Name + " | Email: " + u.Email
}

Penggunaannya sangat mirip dengan OOP klasik: fmt.Println(user1.GetProfile()).

2. Pointer Receiver

Jika kamu ingin mengubah nilai di dalam struct, kamu harus menggunakan Pointer Receiver (ditandai dengan tanda bintang *). Dengan pointer, Go tidak menyalin data, melainkan memberikan alamat memori dari struct asli.

func (u *User) UpdateEmail(newEmail string) {
    u.Email = newEmail
}

Kapan Menggunakan Pointer Receiver?

1. Modifikasi Data: Saat method perlu mengubah field di dalam struct agar perubahan tersebut tersimpan permanen.
2. Efisiensi Memori: Saat struct memiliki ukuran yang sangat besar. Menyalin struct besar setiap kali method dipanggil akan membebani RAM dan CPU (overhead).
3. Konsistensi: Jika beberapa method dalam satu struct sudah menggunakan pointer receiver, sebaiknya semua method lainnya juga menggunakan pointer receiver untuk konsistensi.

Composition: Solusi Go untuk Inheritance

Salah satu fitur utama class di bahasa lain adalah Inheritance (pewarisan). Namun, Go secara sengaja menghindari hal ini untuk mencegah fragile base class problem—kondisi di mana perubahan kecil pada class induk merusak seluruh hierarki class anak yang sangat dalam.

Sebagai gantinya, Go menggunakan Composition melalui fitur yang disebut Struct Embedding. Embedding memungkinkan kita memasukkan satu struct ke dalam struct lain, sehingga struct yang membungkus secara otomatis "mewarisi" field dan method dari struct yang tertanam.

type Address struct {
    City  string
    State string
}

Sekarang kita masukkan Address ke dalam User:

type User struct {
    ID      int
    Name    string
    Address // Embedding
}

Dengan cara ini, kita bisa mengakses user.City secara langsung tanpa harus menulis user.Address.City. Inilah cara Go mencapai fleksibilitas OOP tanpa kompleksitas inheritance yang kaku.

Implementasi Nyata: Struct dalam Dunia Kerja

Dalam pengembangan aplikasi modern, struct bukan sekadar alat pengelompokan data. Berikut adalah skenario di mana struct menjadi sangat krusial bagi seorang Backend Engineer:

1. Parsing JSON (API Development)

Saat membuat REST API, struct digunakan untuk memetakan data JSON dari request atau response. Go menggunakan struct tags untuk menentukan nama field JSON-nya, yang memungkinkan perbedaan antara penamaan di Go (PascalCase) dan JSON (snake_case).

type Product struct {
    Name  string  `json:"product_name"` 
    Price float64 `json:"price"` 
}

2. Mapping Database (ORM)

Saat menggunakan ORM seperti GORM atau driver database standar, struct digunakan untuk merepresentasikan tabel di database menjadi objek di dalam kode program. Hal ini memungkinkan manipulasi data menjadi lebih terstruktur dan type-safe.

3. State Management & Dependency Injection

Struct sering digunakan untuk menyimpan konfigurasi aplikasi atau state dari sebuah service. Misalnya, sebuah struct DatabaseService yang menyimpan koneksi DB, yang kemudian dioper ke berbagai handler melalui pointer agar koneksi tetap konsisten di seluruh aplikasi.

Kapan Harus Menggunakan Struct?

Sebagai panduan praktis bagi pemula, gunakanlah struct jika kamu menemui kondisi berikut:

• Kebutuhan Tipe Data Kustom: Kamu butuh entitas yang memiliki beberapa atribut yang saling berkaitan (misal: Order, Employee, Transaction).
• Pengelompokan Logika: Kamu ingin mengikat beberapa fungsi (method) ke satu set data tertentu agar kode lebih modular dan mudah diuji (testable).
• Interaksi Eksternal: Kamu bekerja dengan format data terstruktur seperti JSON, XML, atau baris tabel database.
• Efisiensi Memori: Kamu ingin mengontrol bagaimana data disimpan dan dikirim menggunakan pointer untuk menghindari copy data yang tidak perlu.

Kesimpulan

Struct adalah bukti bahwa kesederhanaan bisa memberikan kekuatan yang luar biasa. Dengan menghilangkan konsep class yang kaku dan menggantinya dengan kombinasi struct, method, dan composition, Go menawarkan cara yang lebih bersih dan efisien dalam mengelola data kompleks.

Bagi kamu yang terbiasa dengan OOP tradisional, mungkin butuh waktu untuk beradaptasi. Namun, setelah kamu merasakan betapa ringannya kode Go tanpa beban hierarki inheritance yang berat, kamu akan menyadari bahwa pendekatan ini justru mempercepat proses development dan memudahkan maintenance jangka panjang, terutama dalam skala sistem terdistribusi.