Interface dan Interface Kosong di Golang

Halo teman-teman dev 👋

Kita lanjut lagi ke seri Golang Basic, dan kali ini kita akan bahas salah satu konsep penting di Go: interface, termasuk interface kosong (interface{}).

Interface adalah pondasi dari *polymorphism* di Go. Kalau kamu ngerti konsep ini, kamu bisa bikin kode yang lebih fleksibel dan mudah untuk dikembangkan.

🔧 Apa Itu Interface?

Interface di Go adalah kumpulan definisi method. Kalau suatu tipe punya method yang sama persis dengan yang didefinisikan di interface, maka tipe itu otomatis dianggap mengimplementasi interface tersebut, tanpa perlu deklarasi eksplisit (ini yang disebut *implicit implementation*).

Contoh Sederhana:

package main

import "fmt"

type Speaker interface {
    Speak() string
}

type Dog struct{}
func (d Dog) Speak() string {
    return "Guk Guk!"
}

type Cat struct{}
func (c Cat) Speak() string {
    return "Meong~"
}

func introduce(s Speaker) {
    fmt.Println("Hewan ini bersuara:", s.Speak())
}

func main() {
    introduce(Dog{}) // Output: Hewan ini bersuara: Guk Guk!
    introduce(Cat{}) // Output: Hewan ini bersuara: Meong~
}

📝 Di sini:

* Speaker adalah interface-nya.

* Dog dan Cat adalah implementasinya.

* Fungsi introduce() tetap satu, tapi bisa menerima berbagai jenis "pembicara".

💡 Kenapa Perlu Interface?

Interface bikin kode kita:

* Lebih modular

* Lebih testable (bisa mock interface-nya)

* Lebih fleksibel (nggak tergantung pada tipe spesifik)

Contohnya, kalau kamu bikin Logger interface, kamu bisa pakai FileLogger, ConsoleLogger, atau bahkan MockLogger untuk testing.

🧳 Interface Kosong (interface{})

Nah, ini yang sering bikin bingung: interface{}.

Apa Itu interface{}?

interface{} adalah interface yang tidak punya method sama sekali.

Karena semua tipe di Go pasti punya nol atau lebih method, semua tipe bisa dianggap sebagai interface{}.

Makanya interface{} disebut juga sebagai tipe data universal di Go.

Contoh Penggunaan:

func printAnything(val interface{}) {
    fmt.Println(val)
}

func main() {
    printAnything("Hello")
    printAnything(123)
    printAnything(true)
}

📝 printAnything() bisa nerima apa aja, karena parameternya bertipe interface{}.

🧪 Tapi Hati-hati: Type Assertion

Kalau kamu nerima interface{}, kadang kamu pengin tahu: sebenarnya ini tipe apa sih?

Nah, kamu bisa pakai type assertion.

Contoh:

func printType(val interface{}) {
    switch v := val.(type) {
    case int:
        fmt.Println("Ini integer:", v)
    case string:
        fmt.Println("Ini string:", v)
    default:
        fmt.Println("Tipe lain")
    }
}

🧠 Jangan terlalu sering pakai interface{} kalau kamu bisa pakai interface yang lebih spesifik. interface{} bagus buat hal-hal generic, tapi terlalu fleksibel bisa bikin kode rawan bug.

✅ Tips dari Senior:

1. Mulai dari interface yang jelas tujuannya. Jangan langsung pakai interface{} kecuali benar-benar perlu.

2. Gunakan interface untuk testing. Bikin kode kamu bisa diganti mock saat testing.

3. Jangan overengineering. Kalau cuma satu implementasi, belum tentu perlu interface.

✍️ Kesimpulan

* Interface = kontrak method

* Interface kosong = bisa menampung semua tipe

* Gunakan dengan bijak, supaya kode kamu tetap bersih, rapi, dan mudah di-maintain

Kalau kamu masih bingung atau mau contoh lebih lanjut, tinggal tanya ya! 😎