Go From Zero to Hero #18: Belajar Struct di Golang — Solusi Bikin Data Lebih Rapi Saat Map Nggak Cukup

Halo Go Developers! Selamat datang kembali di seri Go From Zero to Hero.

Di artikel sebelumnya, kita sudah mengeksplorasi Map dan kehebatannya dalam mencari data secepat kilat menggunakan pasangan Key-Value. Namun, di akhir artikel lalu, kita sempat menyenggol satu keterbatasan besar dari Map: tipe datanya harus seragam.

Kalau kamu membuat map[string]int, maka semua nilainya wajib berupa angka (int). Kamu tidak bisa memasukkan data teks (string) atau boolean ke dalamnya.

Nyatanya, saat kita membuat aplikasi asli di dunia nyata, data yang kita hadapi bentuknya sangat kompleks. Misal, kita ingin menyimpan data Akun User. Satu akun user pasti memiliki:

• ID -> int
• Nama Lengkap -> string
• Email -> string
• Apakah Premium? -> bool

Jelas Map tidak akan sanggup menangani kasus di atas. Nah, di sinilah Struct (singkatan dari Structure) hadir sebagai penyelamat. Sederhananya, Struct adalah kumpulan dari satu atau lebih variabel yang dibungkus dalam satu nama kustom. Di Go, Struct ini sering dipakai sebagai pengganti konsep Class yang biasa kamu temukan di bahasa pemrograman berorientasi objek (OOP) seperti Java atau C++.

Yuk, kita pelajari bagaimana cara membuat dan menggunakan Struct di Go!

Cara Mendeklarasikan Struct (Membuat Blueprint)

Untuk membuat Struct, kita harus mendefinisikan “cetakan” (blueprint) nya terlebih dahulu di luar fungsi utama (main). Kita gunakan kata kunci type diikuti nama struct-nya, lalu diakhiri kata kunci struct.

Mari kita buat cetakan untuk data User yang kita bicarakan tadi:

package main

import "fmt"

// Menentukan cetakan (blueprint) bernama User
type User struct {
    ID        int
    Nama      string
    Email     string
    IsPremium bool
}

func main() {
    // Kode program akan kita tulis di sini
}

3 Cara Mengisi dan Mengakses Data Struct

Setelah kita berhasil membuat “cetakan” atau blueprint dari sebuah Struct, cetakan tersebut belum memiliki data apa-apa di dalam memori komputer. Langkah selanjutnya adalah mencetak objek nyata dari blueprint tersebut dan mengisi datanya.

Di Go-lang, ada beberapa cara untuk menginisialisasi atau mengisi data ke dalam Struct. Mari kita bedah satu per satu beserta plus-minusnya.

1. Mengisi Data Berdasarkan Urutan Field (Positional Syntax)

Cara pertama ini adalah cara yang paling ringkas secara penulisan teks. Kamu cukup memanggil nama Struct-nya, lalu masukkan nilainya di dalam kurung kurawal {} secara berurutan sesuai dengan urutan variabel yang kamu tulis di dalam blueprint.

package main

import "fmt"

type User struct {
    ID        int
    Nama      string
    Email     string
    IsPremium bool
}

func main() {
    // Mengisi data berurutan: ID, Nama, Email, IsPremium
    user1 := User{1, "Budi Santoso", "budi@gmail.com", true}

    fmt.Println(user1) // Output: {1 Budi Santoso budi@gmail.com true}
}

2. Mengisi Data Berdasarkan Nama Field (Name-Value Syntax) — REKOMENDASI!

Cara kedua ini adalah cara yang paling aman, standar industri, dan sangat direkomendasikan oleh komunitas Go. Kamu wajib menuliskan nama field-nya terlebih dahulu diikuti tanda titik dua :, baru kemudian nilainya.

// Mengisi data secara eksplisit menyebutkan nama field-nya
user2 := User{
    Nama:      "Siti Aminah",
    ID:        2,
    IsPremium: false,
    Email:     "siti@gmail.com",
}

⚡ Kelebihan: * Bebas Acak: Kamu tidak perlu pusing memikirkan urutan variabel di dalam blueprint. Seperti contoh di atas, kita bisa mengisi Nama duluan sebelum ID.

• Kebal Error: Jika urutan field di dalam cetakan Struct berubah di masa depan, kodemu akan tetap berjalan dengan aman tanpa error.

• Bisa Dikosongkan: Jika ada field yang tidak kamu isi, Go otomatis akan memberikannya nilai default kosong (Zero Value).

3. Mengakses dan Mengubah Nilai Menggunakan Tanda Titik (.)

Setelah objek Struct berhasil dibuat dan diisi datanya, bagaimana cara kita mengambil atau mengubah salah satu datanya saja? Caranya sangat mudah, cukup gunakan operator tanda titik (.).

Perhatikan contoh lengkap di bawah ini:

package main

import "fmt"

type User struct {
    ID        int
    Nama      string
    Email     string
    IsPremium bool
}

func main() {
    user := User{
        ID:        1,
        Nama:      "Andi",
        Email:     "andi@gmail.com",
        IsPremium: false,
    }

    // --- CARA MENGAKSES (MEMBACA) DATA ---
    fmt.Println("Nama User:", user.Nama)   // Output: Nama User: Andi
    fmt.Println("Email User:", user.Email) // Output: Email User: andi@gmail.com

    // --- CARA MENGUBAH DATA DI TENGAH JALAN ---
    // Ceritanya si Andi baru saja upgrade ke akun premium
    user.IsPremium = true
    user.Nama = "Andi Perkasa" // Mengubah nama lama

    fmt.Println("Status Premium Terbaru:", user.IsPremium) // Output: true
    fmt.Println("Nama Terbaru:", user.Nama)               // Output: Andi Perkasa
}

Anonymous Struct (Struct Tanpa Nama)

Secara standar, kita selalu membuat cetakan Struct di luar fungsi main agar bisa digunakan berulang kali. Namun, ada kalanya kita berada di situasi di mana kita hanya membutuhkan sebuah Struct untuk satu kali pakai saja di dalam sebuah fungsi, dan tidak akan pernah dipanggil lagi di tempat lain.

Daripada mengotori baris kode dengan membuat cetakan global, Go menyediakan fitur bernama Anonymous Struct (Struct tanpa nama).

Gaya ini sangat sering dipakai oleh Backend Engineer saat membuat unit testing (khususnya konsep Table-Driven Tests) atau saat ingin memformat data kiriman (Response) API berbentuk JSON yang sifatnya spesifik untuk satu endpoint saja.

Berikut cara mendeklarasikan sekaligus mengisi nilainya secara instan:

package main

import "fmt"

func main() {
    // Membuat cetakan sekaligus mengisi datanya langsung tanpa nama struct
    pembayaran := struct {
        Metode string
        Total  int
    }{
        Metode: "Transfer Bank",
        Total:  150000,
    }

    fmt.Printf("Aplikasi menerima pembayaran via %s sebesar Rp%d\n", pembayaran.Metode, pembayaran.Total)
}

Struct Embedded (Struct di Dalam Struct)

Bayangkan aplikasi kita semakin berkembang, dan sekarang kita harus menyimpan data alamat lengkap dari User. Sebuah alamat biasanya terdiri dari variabel Kota dan Provinsi.

Bisa saja kita langsung memasukkan variabel Kota dan Provinsi ke dalam struct User utama. Tapi bagaimana jika nanti ada entitas lain, seperti struct Toko atau struct Gudang, yang juga membutuhkan data alamat? Menulis ulang variabel yang sama di banyak tempat tentu tidak efisien (Don’t Repeat Yourself).

Solusi cerdasnya adalah menggunakan Struct Embedded, yaitu memasukkan sebuah Struct ke dalam Struct lainnya.

Mari kita lihat bagaimana cara membuatnya:

package main

import "fmt"

// 1. Kita buat struct Alamat yang mandiri
type Alamat struct {
    Kota     string
    Provinsi string
}

// 2. Kita masukkan struct Alamat ke dalam struct User
type User struct {
    ID        int
    Nama      string
    IsPremium bool
    Domisili  Alamat // Struct Embedded
}

func main() {
    // 3. Cara mengisi data Struct Embedded
    userPremium := User{
        ID:        99,
        Nama:      "Rian",
        IsPremium: true,
        Domisili: Alamat{
            Kota:     "Bandung",
            Provinsi: "Jawa Barat",
        },
    }

    // 4. Cara mengakses datanya: Gunakan tanda titik dua kali!
    fmt.Println("Nama User:", userPremium.Nama)
    fmt.Println("Kota Asal:", userPremium.Domisili.Kota) 
    // Output: Kota Asal: Bandung
}

Dengan teknik Embedded seperti ini, kodemu menjadi jauh lebih modular, rapi, dan mudah dirawat jika suatu saat struktur datanya membutuhkan perubahan.

📝 Soal Cerita: Buku Kas Digital Laundry

Budi memiliki usaha laundry. Setiap hari, ia ingin mencatat nama Pelanggan Utama dan Total Pemasukan yang didapat. Karena Budi pelupa, ia meminta bantuanmu untuk membuatkan program pencatatan digital sederhana.

🛠️ Instruksi Struktur Data:

Buat Struct DataLaundry dengan field: NamaPelanggan (string) dan TotalBayar (int).

Buat Map BukuKas dengan Key: Tanggal (string) dan Value: objek Struct DataLaundry.

💻 Skenario Program:

Program akan meminta Budi untuk mengetikkan Tanggal Hari Ini, Nama Pelanggan, dan Total Bayar melalui keyboard menggunakan bufio. Setelah data disimpan ke dalam Map, program akan menampilkan ringkasan nota kasnya.

📥 Contoh Input & Output Terminal

(Teks yang bercetak tebal adalah apa yang diketik/diinput oleh Budi lewat keyboard)

=== INPUT BUKU KAS LAUNDRY ===
Masukkan Tanggal (DD-MM) : 13-07
Masukkan Nama Pelanggan  : Andi Perkasa
Masukkan Total Bayar (Rp): 45000

=== NOTA KAS BERHASIL DISIMPAN ===
Tanggal Nota : 13-07
Pelanggan    : Andi Perkasa
Total Pemasukan : Rp 45000

📌 Petunjuk Bantuan (Hint)

Biar kamu gak bingung pas mulai ngetik kodenya di VS Code, ini beberapa bocoran penting yang wajib kamu perhatikan:

1. Jangan Pakai fmt.Scanln: Ingat, nama pelanggan (Andi Perkasa) mengandung spasi. Jika kamu pakai fmt.Scanln, program akan eror atau terpotong. Gunakan bufio.NewScanner(os.Stdin) dan .Scan() untuk membaca input teks secara utuh.

2. Cara Bungkus Data ke Struct: Setelah membaca input dari user, masukkan data tersebut ke dalam variabel struct dengan gaya Name-Value seperti ini:

laundryBaru := DataLaundry{
    NamaPelanggan: inputNama,
    TotalBayar:    inputBayar,
}

3. Cara Simpan ke Map: Inisialisasi map kamu terlebih dahulu dengan make(map[string]DataLaundry). Setelah itu, gunakan tanggal sebagai key untuk menyimpan struct tadi: BukuKas[inputTanggal] = laundryBaru.

Gimana, tertantang buat nyelesaiin kuis Buku Kas Laundry di atas? Yuk, tulis kode Go-lang versi kamu dan paste di kolom komentar di bawah! Nanti kita bahas dan koreksi bareng kalau ada yang eror.

Kesimpulan

Luar biasa! Kamu baru saja menuntaskan salah satu topik paling fundamental dalam pemrograman Go-lang. Dengan memahami Struct, kamu sekarang sudah bisa melompat dari pemrogram dasar menuju ke level arsitektur data yang lebih profesional.

Mari kita ingat kembali poin-poin penting seputar Struct:

1. Blueprint Kustom: Struct digunakan untuk membuat tipe data baru yang menggabungkan berbagai macam tipe data berbeda ke dalam satu cetakan objek dunia nyata.
2. Name-Value Syntax: Selalu gunakan gaya penulisan eksplisit menyebutkan nama field saat mengisi data Struct agar kodemu aman dari error di masa depan.
3. Anonymous Struct: Manfaatkan untuk data sekali pakai, terutama saat berurusan dengan data testing atau payload JSON API yang spesifik.
4. Embedded Struct: Gunakan teknik ini untuk mewariskan atau mengelompokkan struktur data (seperti menyisipkan struct Alamat ke dalam struct User) agar kodemu tetap Reusable dan bersih.

Kemampuan menyusun Struct dengan benar—seperti menggabungkannya ke dalam Slice ([]NamaStruct)—adalah kunci utama saat kamu mulai membangun aplikasi yang terintegrasi dengan database nyata.

Next Teaser: Menambahkan “Nyawa” ke Struct Menggunakan Method!

Sampai detik ini, Struct yang kita buat baru sebatas bertindak sebagai tempat penyimpanan data yang pasif. Objek User atau Alamat yang kita cetak hanya bisa menyimpan nilai tanpa bisa melakukan aksi apa-apa.

Jika di bahasa pemrograman OOP lain sebuah Class bisa memiliki fungsi di dalamnya, bagaimana cara Go melakukannya?

Di artikel berikutnya, Go From Zero to Hero #12, kita akan belajar tentang Struct Method. Kita akan memberikan “nyawa” dan perilaku (behavior) kepada Struct, sehingga objek yang kita buat nantinya bisa mengeksekusi fungsi khusus miliknya sendiri.

Sampai jumpa di artikel berikutnya, tetap semangat eksperimen kodenya, dan happy coding!