Tipe Data Go Lang: Primitif ke Kompleks untuk Developer Keren

Halo, gaes! Apa kabar? Siapa nih yang lagi semangat banget belajar Go Lang? Mantul! Nah, kali ini kita bakal ngulik salah satu fundamental paling penting dalam ngoding: tipe data. Ibarat mau bangun rumah, tipe data itu kayak bahan-bahan dasarnya. Kalo kita paham karakternya, kita bisa bikin rumah (baca: aplikasi) yang kokoh, efisien, dan estetik!

Jangan khawatir, ngab. Kita bakal bahas ini santuy, nggak pake kaku-kaku. Skuy!

Kenapa Tipe Data Penting Banget di Go?

Go itu statically typed, gaes. Artinya, setiap variabel yang kamu deklarasikan itu harus punya tipe data yang jelas. Ini beda sama bahasa dinamis kayak Python atau JavaScript. Keuntungannya?

• Performa Ngebut: Go tahu persis berapa memori yang dibutuhkan buat nyimpen data, jadi lebih efisien.
• Nangkep Error Lebih Awal: Banyak bug bisa ketahuan pas compile-time, bukan pas aplikasi udah jalan. Ini bikin hidup developer lebih tenang.
• Code Lebih Jelas: Gampang dibaca dan dipahami sama developer lain (termasuk kamu di masa depan!).

Oke, yuk kita spill satu per satu tipe data di Go!

I. Tipe Data Primitif: Pondasi Utama Siap Tempur!

Tipe data primitif itu kayak bahan bangunan dasar: batu bata, semen, pasir. Mereka paling dasar dan jadi fondasi buat tipe data yang lebih kompleks.

1. Angka (Numerik)

Buat ngurusin angka, Go punya beberapa varian nih:

• Integer (Bilangan Bulat):

  • int: Ini tipe integer default yang ukurannya menyesuaikan arsitektur CPU (32-bit atau 64-bit). Paling sering dipake.
  • int8, int16, int32, int64: Buat angka positif dan negatif, dengan ukuran memori spesifik. Pilih yang sesuai kebutuhan biar nggak boros memori.
  • uint, uint8, uint16, uint32, uint64: Mirip int, tapi khusus buat angka non-negatif (0 dan positif). u itu singkatan dari unsigned.
  • byte: Ini sebenarnya alias dari uint8, sering dipake buat data biner.

  package main
  
  import "fmt"
  
  func main() {
      var umur int = 30
      var populasi int64 = 7_000_000_000 // underscore bantu readability
      var nilaiMaks uint8 = 255          // Max value for uint8
  
      fmt.Println("Umur:", umur)
      fmt.Println("Populasi Bumi:", populasi)
      fmt.Println("Nilai Maks uint8:", nilaiMaks)
  }
  

• Floating-Point (Bilangan Desimal):

  • float32: Buat angka desimal dengan presisi lebih rendah (sekitar 7 digit desimal).
  • float64: Ini yang paling umum dipake, presisinya lebih tinggi (sekitar 15 digit desimal).

  package main
  
  import "fmt"
  
  func main() {
      var ipk float32 = 3.85
      var pi float64 = 3.14159265359
  
      fmt.Println("IPK:", ipk)
      fmt.Println("Nilai Pi (float64):", pi)
  }
  

• Complex Numbers (Bilangan Kompleks):

  • complex64 (float32 real + float32 imaginary)
  • complex128 (float64 real + float64 imaginary) Jarang dipake buat aplikasi umum, tapi penting buat komputasi saintifik.

2. Boolean (bool)

Ini tipe data buat nilai kebenaran: true atau false. Cocok buat logika kondisional.

package main

import "fmt"

func main() {
    var isRaining bool = true
    var hasLicense bool = false

    if isRaining {
        fmt.Println("Bawa payung!")
    }

    if !hasLicense {
        fmt.Println("Duh, harus les mengemudi nih.")
    }
}

3. String (string)

Buat nyimpen teks, gaes. Di Go, string itu immutable, artinya setelah dibikin, isinya nggak bisa diubah. Kalo mau diubah, Go akan bikin string baru.

package main

import "fmt"

func main() {
    var namaDepan string = "Budi"
    var namaBelakang string = "Pekerti"

    namaLengkap := namaDepan + " " + namaBelakang // Konkatenasi string
    fmt.Println("Halo,", namaLengkap)

    // String literal multi-baris
    motivasi := `
    Belajar Go itu seru banget,
    bikin coding jadi makin asik.
    Semangat terus, gaes!
    `
    fmt.Println(motivasi)
}

4. Rune (rune)

rune itu alias dari int32, khusus buat merepresentasikan karakter Unicode. Penting banget buat nge-handle teks multibahasa (emoji, karakter Jepang, dll). Kalo kita iterasi string, Go akan ngasih rune bukan byte per karakter.

package main

import "fmt"

func main() {
    karakterA := 'A' // Ini adalah rune, bukan string
    karakterHati := '❤️'

    fmt.Printf("Karakter A: %c (Unicode: %U)\n", karakterA, karakterA)
    fmt.Printf("Karakter Hati: %c (Unicode: %U)\n", karakterHati, karakterHati)

    // Iterasi string dengan rune
    for i, r := range "Hello 👋" {
        fmt.Printf("Index: %d, Rune: %c (Unicode: %U)\n", i, r, r)
    }
}

II. Tipe Data Kompleks: Merangkai Data Jadi Lebih Bermakna!

Nah, kalo primitif itu bahan dasar, tipe data kompleks ini ibarat arsitektur rumahnya. Kita bisa ngerangkai beberapa data jadi satu kesatuan yang lebih terstruktur.

1. Array

Array itu kumpulan data dengan tipe yang sama dan ukuran yang tetap. Begitu didefinisikan, ukurannya nggak bisa diubah.

package main

import "fmt"

func main() {
    var angka [5]int // Array dengan 5 elemen integer
    angka[0] = 10
    angka[1] = 20
    // ... dst
    angka[4] = 50

    fmt.Println("Array angka:", angka)         // Output: [10 20 0 0 50] (index 2 & 3 default zero value)
    fmt.Println("Elemen pertama:", angka[0])
    fmt.Println("Ukuran array:", len(angka))

    // Inisialisasi langsung
    namaHari := [7]string{"Minggu", "Senin", "Selasa", "Rabu", "Kamis", "Jumat", "Sabtu"}
    fmt.Println("Hari ini:", namaHari[2])
}

Tips: Karena ukurannya tetap, array jarang dipake langsung di Go buat kasus umum. Kita lebih sering pake slice.

2. Slice

Ini dia bintangnya koleksi data di Go! Slice itu mirip array, tapi ukuran dinamis. Dia bisa tumbuh atau menyusut sesuai kebutuhan. Slice itu dibangun di atas array, semacam "view" ke array yang mendasarinya.

package main

import "fmt"

func main() {
    // Membuat slice
    var buah []string // Slice kosong, zero value-nya nil
    fmt.Println("Slice buah (awal):", buah, "Panjang:", len(buah), "Kapasitas:", cap(buah))

    // Menambah elemen dengan append
    buah = append(buah, "Apel")
    buah = append(buah, "Pisang", "Mangga") // Bisa nambah beberapa sekaligus
    fmt.Println("Slice buah (setelah append):", buah, "Panjang:", len(buah), "Kapasitas:", cap(buah))

    // Membuat slice dengan make
    // make([]tipe, panjang, kapasitas)
    nilai := make([]int, 3, 5) // Panjang 3, kapasitas 5
    nilai[0] = 90
    nilai[1] = 85
    nilai[2] = 95
    fmt.Println("Slice nilai:", nilai, "Panjang:", len(nilai), "Kapasitas:", cap(nilai))

    nilai = append(nilai, 100) // nambah satu elemen
    fmt.Println("Slice nilai (append lagi):", nilai, "Panjang:", len(nilai), "Kapasitas:", cap(nilai))

    // Slicing (mengambil sebagian dari slice)
    sliceSebagian := nilai[1:3] // Dari index 1 (inklusif) sampai index 3 (eksklusif)
    fmt.Println("Slice sebagian:", sliceSebagian) // Output: [85 95]
}

Best Practice: Pahami konsep len (panjang elemen) dan cap (kapasitas memori alokasi) di slice. Ini kunci efisiensi!

3. Map

Map itu kumpulan pasangan key-value. Mirip kamus kalo di bahasa lain. Setiap key itu unik dan punya value.

package main

import "fmt"

func main() {
    // Membuat map dengan make
    // make(map[tipe_key]tipe_value)
    dataKaryawan := make(map[string]string) // Key string, Value string

    dataKaryawan["id001"] = "Budi Santoso"
    dataKaryawan["id002"] = "Citra Dewi"
    dataKaryawan["id003"] = "Andi Wijaya"

    fmt.Println("Data karyawan:", dataKaryawan)

    // Mengakses nilai
    fmt.Println("Nama karyawan ID002:", dataKaryawan["id002"])

    // Mengecek keberadaan key (mantul nih!)
    nama, found := dataKaryawan["id004"]
    if found {
        fmt.Println("Nama karyawan ID004:", nama)
    } else {
        fmt.Println("Karyawan ID004 tidak ditemukan.")
    }

    // Menghapus elemen
    delete(dataKaryawan, "id001")
    fmt.Println("Data karyawan setelah hapus ID001:", dataKaryawan)

    // Inisialisasi langsung
    nilaiMapel := map[string]int{
        "Matematika": 90,
        "Fisika":     85,
        "Kimia":      92,
    }
    fmt.Println("Nilai mata pelajaran:", nilaiMapel)
}

Best Practice: Selalu cek keberadaan key menggunakan comma-ok idiom (value, found := myMap["key"]) sebelum mengakses nilainya, biar nggak panik kalo key nggak ada.

4. Struct

Struct itu kayak cetak biru (blueprint) buat membuat tipe data kustom sendiri. Kita bisa nggabungin berbagai tipe data (primitif atau kompleks) jadi satu objek yang punya makna.

package main

import "fmt"

// Mendefinisikan struct 'Mahasiswa'
type Mahasiswa struct {
    Nama    string
    NIM     string
    Jurusan string
    Umur    int
    IPK     float32
    isActive bool
}

func main() {
    // Membuat instance struct 'Mahasiswa'
    mhs1 := Mahasiswa{
        Nama:    "Anisa Putri",
        NIM:     "2022001",
        Jurusan: "Teknik Informatika",
        Umur:    20,
        IPK:     3.95,
        isActive: true,
    }

    // Mengakses field struct
    fmt.Println("Nama Mahasiswa:", mhs1.Nama)
    fmt.Println("Jurusan:", mhs1.Jurusan)

    // Mengubah nilai field
    mhs1.IPK = 4.0
    fmt.Println("IPK terbaru:", mhs1.IPK)

    // Struct tanpa nama field (anonim)
    buku := struct {
        Judul string
        Penulis string
    }{
        Judul: "Dunia Sophie",
        Penulis: "Jostein Gaarder",
    }
    fmt.Println("Buku:", buku.Judul, "oleh", buku.Penulis)
}

Best Practice: Pake struct tag buat integrasi dengan JSON, XML, atau database. Ini super power buat API!

5. Interface

Oke, gaes, ini yang agak "meta" tapi keren banget. Interface di Go itu bukan kelas, bukan juga objek. Dia itu cuma kontrak atau spesifikasi perilaku. Interface mendefinisikan metode apa saja yang harus dimiliki oleh sebuah tipe data. Kalau sebuah tipe data punya semua metode yang didefinisikan di suatu interface, berarti tipe data itu "mengimplementasikan" interface tersebut secara implisit.

package main

import "fmt"

// Mendefinisikan interface 'Bentuk'
type Bentuk interface {
    Luas() float64 // Semua tipe yang mengimplementasikan Bentuk harus punya metode Luas()
    Keliling() float64 // Dan juga Keliling()
}

// Mendefinisikan struct 'Persegi'
type Persegi struct {
    Sisi float64
}

// Metode Luas untuk Persegi
func (p Persegi) Luas() float64 {
    return p.Sisi * p.Sisi
}

// Metode Keliling untuk Persegi
func (p Persegi) Keliling() float64 {
    return 4 * p.Sisi
}

// Mendefinisikan struct 'Lingkaran'
type Lingkaran struct {
    JariJari float64
}

// Metode Luas untuk Lingkaran
func (l Lingkaran) Luas() float64 {
    return 3.14 * l.JariJari * l.JariJari
}

// Metode Keliling untuk Lingkaran
func (l Lingkaran) Keliling() float64 {
    return 2 * 3.14 * l.JariJari
}

// Fungsi yang bisa menerima segala Bentuk
func cetakInfoBentuk(b Bentuk) {
    fmt.Printf("Luas: %.2f, Keliling: %.2f\n", b.Luas(), b.Keliling())
}

func main() {
    persegiPanjang := Persegi{Sisi: 5}
    lingkaranku := Lingkaran{JariJari: 7}

    // Karena Persegi dan Lingkaran punya metode Luas() dan Keliling(),
    // mereka secara otomatis mengimplementasikan interface Bentuk.
    cetakInfoBentuk(persegiPanjang)
    cetakInfoBentuk(lingkaranku)

    // Interface kosong: interface{}
    // Ini bisa menampung TIPE DATA APAPUN. Hati-hati makenya, gaes!
    var dataKosong interface{}
    dataKosong = "Ini string!"
    fmt.Println(dataKosong)
    dataKosong = 123
    fmt.Println(dataKosong)
    dataKosong = true
    fmt.Println(dataKosong)

    // Best Practice: Hindari interface{} kecuali memang perlu fleksibilitas super tinggi
    // dan kamu siap dengan type assertion/type switch.
}

Best Practice: Gunakan interface untuk mencapai polymorphism dan abstraksi. Ini bikin code kamu lebih modular dan gampang di-test. Tapi, hindari interface{} (interface kosong) kalo nggak bener-bener butuh, karena bisa bikin code kurang jelas dan rawan runtime error.

Kesimpulan: Kuasai Tipe Data, Kuasai Go!

Gimana, gaes? Udah kebayang kan gimana Go ngatur datanya? Dari integer yang simpel sampe interface yang abstraktif, semuanya punya peran penting dalam membangun aplikasi yang robust.

Menguasai tipe data di Go itu kunci buat nulis code yang efisien, aman dari bug, dan gampang di-maintain. Jadi, jangan cuma sekadar tahu, tapi pahami vibes masing-masing tipe data ini. Terus eksplorasi, bikin proyek kecil, dan jangan takut nyoba!

Dengan pemahaman yang kuat tentang tipe data, kamu siap banget buat nge-level up skill Go Lang kamu. Keep ngoding, keep belajar, dan tetap semangat ya, ngab!