Interface di Golang: Implementasi Implisit, any, dan Jebakan nil

Interface adalah kumpulan method

Tipe interface berisi daftar signature method. Tipe apa pun yang punya method-method itu memenuhi interface tersebut, tanpa perlu deklarasi yang menyatakannya.

package main

import (
	"fmt"
	"math"
)

type Shape interface {
	Area() float64
	Perimeter() float64
}

type Rect struct{ W, H float64 }

func (r Rect) Area() float64      { return r.W * r.H }
func (r Rect) Perimeter() float64 { return 2 * (r.W + r.H) }

type Circle struct{ R float64 }

func (c Circle) Area() float64      { return math.Pi * c.R * c.R }
func (c Circle) Perimeter() float64 { return 2 * math.Pi * c.R }

func describe(s Shape) {
	fmt.Printf("%T area=%.2f perimeter=%.2f\n", s, s.Area(), s.Perimeter())
}

func main() {
	shapes := []Shape{Rect{3, 4}, Circle{1}}
	for _, s := range shapes {
		describe(s)
	}
}

Baik Rect maupun Circle tidak menyebut Shape sama sekali. Itulah implementasi implisit, ciri khas interface di Go. Artinya kamu bisa mendefinisikan interface di package-mu sendiri yang sudah dipenuhi oleh tipe dari package lain, tanpa menyentuh kode mereka.

Interface kecil dari standard library

Kode Go lebih menyukai interface dengan satu atau dua method. Yang paling penting:

Karena io.Reader hanya punya satu method, puluhan tipe mengimplementasikannya, dan fungsi apa pun yang menerima io.Reader bisa bekerja dengan semuanya:

package main

import (
	"bytes"
	"fmt"
	"io"
	"strings"
)

func countBytes(r io.Reader) (int64, error) {
	return io.Copy(io.Discard, r)
}

type Temp float64

func (t Temp) String() string { return fmt.Sprintf("%.1f°C", float64(t)) }

func main() {
	n1, _ := countBytes(strings.NewReader("hello"))
	n2, _ := countBytes(bytes.NewBufferString("hello, gopher"))
	fmt.Println(n1, n2)

	var sb strings.Builder // an io.Writer
	fmt.Fprintf(&sb, "%d + %d = %d", 2, 2, 4)
	fmt.Println(sb.String())

	fmt.Println(Temp(21.5)) // fmt calls String()
}

Pepatah Go berbunyi "the bigger the interface, the weaker the abstraction" (makin besar interface, makin lemah abstraksinya). Interface yang lebih besar dibangun dengan menggabungkan yang kecil: io.ReadWriter adalah Reader ditambah Writer, ditulis dengan menyematkan (embed) satu interface di dalam interface lain.

any: interface kosong

interface{} tidak punya method, jadi setiap tipe memenuhinya. Go 1.18 menambahkan any sebagai alias; keduanya identik.

package main

import "fmt"

func main() {
	var v any

	v = 42
	fmt.Printf("%v %T\n", v, v)

	v = "text"
	fmt.Printf("%v %T\n", v, v)

	v = []int{1, 2}
	fmt.Printf("%v %T\n", v, v)

	items := []any{1, "two", 3.0, nil}
	fmt.Println(len(items))

	if s, ok := v.([]int); ok {
		fmt.Println("slice of len", len(s))
	}
}

Nilai any bisa menampung apa saja, tapi hampir tidak ada yang bisa kamu lakukan dengannya sampai tipe konkretnya dipulihkan dengan type assertion atau type switch. Pilih interface sungguhan atau generics kalau kumpulan tipenya sudah diketahui. any cocok untuk data yang benar-benar dinamis, seperti JSON hasil decode yang bentuknya tidak diketahui, dan untuk mencetak.

Isi sebuah nilai interface

Nilai interface adalah pasangan: tipe dinamis dan nilai dinamis. var s Shape = Rect{3, 4} menyimpan tipe Rect dan salinan nilainya. Memanggil s.Area() akan mencari method milik Rect saat program berjalan.

Interface bernilai nil hanya kalau kedua bagiannya kosong. Aturan ini memicu bug paling membingungkan di Go.

Jebakan interface nil

Pointer nil yang disimpan di interface menghasilkan interface yang tidak nil.

package main

import "fmt"

type MyError struct{ Msg string }

func (e *MyError) Error() string { return e.Msg }

func validate(ok bool) error {
	var err *MyError // nil pointer
	if !ok {
		err = &MyError{"invalid input"}
	}
	return err // BUG: returns a non-nil error even when ok is true
}

func validateFixed(ok bool) error {
	if !ok {
		return &MyError{"invalid input"}
	}
	return nil
}

func main() {
	err := validate(true)
	fmt.Println(err == nil) // false
	fmt.Printf("%T %v\n", err, err == (*MyError)(nil))

	fmt.Println(validateFixed(true) == nil) // true
}

Output:

false
*main.MyError true
true

validate(true) mengembalikan interface error yang menyimpan tipe *MyError dan nilai nil. Interface itu punya tipe, jadi ia tidak sama dengan nil, dan cabang if err != nil milik pemanggil pun dijalankan. Memanggil err.Error() di sana lalu akan panic saat mengakses field dari receiver yang nil.

Solusinya sederhana: deklarasikan variabelnya sebagai error, bukan sebagai tipe pointer konkret, atau kembalikan nil literal di jalur sukses. Jangan pernah mengembalikan tipe pointer error konkret dari fungsi yang hasilnya error. Jebakan yang sama berlaku untuk interface apa pun, bukan hanya error.

Memeriksa bahwa sebuah tipe mengimplementasikan interface

Implementasi diperiksa di tempat sebuah nilai di-assign ke interface. Kalau belum ada kode yang melakukannya, kesalahan pada signature method tidak akan ketahuan. Blank assignment di level package membuat pemeriksaan itu eksplisit:

var _ io.Writer = (*LogWriter)(nil)
var _ fmt.Stringer = Temp(0)

Ini tidak menambah biaya apa pun saat program berjalan. Kalau *LogWriter punya Write(p []byte) error dan bukan Write(p []byte) (int, error), build akan gagal:

cannot use (*LogWriter)(nil) (value of type *LogWriter) as io.Writer value in variable declaration: *LogWriter does not implement io.Writer (wrong type for method Write)
		have Write([]byte) error
		want Write([]byte) (int, error)

Pointer receiver dan interface

Kalau sebuah method punya pointer receiver, hanya tipe pointer yang memiliki method itu. *Counter memenuhi interface lewat method tersebut; Counter tidak. Compiler akan bilang Counter does not implement Incrementer (method Inc has pointer receiver). Simpan &Counter{} di interface. Halaman method menjelaskan method set.

Accept interfaces, return structs

Pedoman Go yang umum: fungsi sebaiknya menerima parameter berupa interface dan mengembalikan tipe konkret.

• Menerima interface memungkinkan pemanggil mengirim apa pun yang cocok, termasuk tiruan (fake) untuk pengujian. Fungsi yang membaca data sebaiknya menerima io.Reader, bukan *os.File.
• Mengembalikan tipe konkret memungkinkan pemanggil memakai semua method dan field-nya, sekaligus menghindari jebakan interface nil. os.Open mengembalikan *os.File, bukan io.Reader.

Kebiasaan yang berkaitan: definisikan interface di tempat ia dipakai, bukan di tempat ia diimplementasikan. Kalau service-mu butuh sesuatu yang bisa Get(id) seorang user, deklarasikan interface satu method di package service-mu, dan biarkan package database cukup meng-export struct-nya.

package main

import (
	"errors"
	"fmt"
)

// Declared by the consumer, with only what it needs.
type UserGetter interface {
	GetUser(id int) (string, error)
}

func greet(db UserGetter, id int) string {
	name, err := db.GetUser(id)
	if err != nil {
		return "hello, stranger"
	}
	return "hello, " + name
}

// A fake for tests or examples: no mocking library needed.
type fakeDB map[int]string

func (f fakeDB) GetUser(id int) (string, error) {
	if n, ok := f[id]; ok {
		return n, nil
	}
	return "", errors.New("not found")
}

func main() {
	db := fakeDB{1: "Ana"}
	fmt.Println(greet(db, 1))
	fmt.Println(greet(db, 2))
}

Membandingkan nilai interface

Dua nilai interface sama kalau tipe dinamisnya identik dan nilai dinamisnya sama. Kalau tipe dinamisnya tidak bisa dibandingkan (slice, map), == tetap bisa dikompilasi tapi panic saat program berjalan: runtime error: comparing uncomparable type []int.

Kesalahan umum

• Mengembalikan pointer nil bertipe sebagai interface. Kembalikan nil literal.
• Membuat interface terlalu dini. Tulis tipe konkretnya dulu. Tambahkan interface saat implementasi kedua atau sebuah pengujian membutuhkannya.
• Pointer ke interface. *io.Reader hampir tidak pernah benar. Interface sudah menyimpan pointer kalau kamu menyimpan pointer di dalamnya.
• Interface yang besar. Interface dengan sepuluh method sulit diimplementasikan dan sulit dibuat tiruannya. Pecah menjadi beberapa interface.