Type Assertion di Golang: x.(T), Comma-ok, dan Type Switch

x.(T): mengambil nilai dari interface

Nilai interface menyembunyikan tipe konkret yang ada di dalamnya. Type assertion x.(T) meminta tipe itu kembali.

package main

import "fmt"

func main() {
	var v any = "gopher"

	s := v.(string) // v holds a string: ok
	fmt.Println(s, len(s))

	n, ok := v.(int) // comma-ok: no panic on mismatch
	fmt.Println(n, ok)

	if str, ok := v.(string); ok {
		fmt.Println("string of length", len(str))
	}
}

Output:

gopher 6
0 false
string of length 6

x harus bertipe interface. Assertion pada tipe konkret gagal dikompilasi: invalid operation: s (variable of type string) is not an interface.

Bentuk satu nilai bisa panic

Kalau assertion-nya salah, bentuk satu nilai akan panic dengan pesan yang menyebut kedua tipe:

package main

import "fmt"

func main() {
	defer func() {
		fmt.Println("recovered:", recover())
	}()

	var v any = 42
	s := v.(string)
	fmt.Println(s)
}

Output:

recovered: interface conversion: interface {} is int, not string

Pakai bentuk satu nilai hanya kalau tipe yang berbeda berarti kesalahan pemrograman yang memang ingin kamu hentikan dengan crash. Di tempat lain, pakai comma-ok. Saat gagal, comma-ok memberi zero value dari T dan false.

Assertion pada interface yang nil juga gagal: var v any; v.(string) akan panic dengan interface conversion: interface {} is nil, not string, dan bentuk comma-ok mengembalikan "", false.

Assertion ke interface lain

T boleh berupa tipe interface. Assertion-nya lalu berhasil jika nilai dinamisnya mengimplementasikan T, dan hasilnya tetap menyimpan nilai dinamis yang sama. Dengan cara inilah pustaka standar memeriksa kemampuan opsional.

package main

import (
	"fmt"
	"strings"
)

type Temp float64

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

func describe(v any) string {
	if s, ok := v.(fmt.Stringer); ok {
		return "Stringer: " + s.String()
	}
	return fmt.Sprintf("plain value: %v", v)
}

func main() {
	fmt.Println(describe(Temp(21.5)))
	fmt.Println(describe(42))

	// io.Copy uses the same trick to check for WriterTo / ReaderFrom.
	var r any = strings.NewReader("x")
	_, hasLen := r.(interface{ Len() int })
	fmt.Println("has Len:", hasLen)
}

io.Copy memeriksa apakah sumbernya mengimplementasikan io.WriterTo dan memakainya kalau iya. fmt memeriksa Stringer dan error. Pola ini membuat interface kecil tetap kecil, sementara pemanggil tetap mendapat manfaat dari implementasi yang lebih kaya.

Type switch

Ketika sebuah nilai bisa berupa salah satu dari beberapa tipe, type switch menggantikan rangkaian assertion. x.(type) hanya sah di dalam switch.

package main

import (
	"fmt"
	"strconv"
)

func toString(v any) string {
	switch x := v.(type) {
	case nil:
		return "nil"
	case string:
		return x // x is a string here
	case int, int64:
		return fmt.Sprintf("integer %v", x) // x is any: two types in one case
	case float64:
		return strconv.FormatFloat(x, 'f', 2, 64)
	case fmt.Stringer:
		return x.String()
	case error:
		return "error: " + x.Error()
	default:
		return fmt.Sprintf("unhandled %T", x)
	}
}

func main() {
	values := []any{"hi", 7, int64(8), 3.14159, nil, fmt.Errorf("boom"), []int{1}}
	for _, v := range values {
		fmt.Println(toString(v))
	}
}

Output:

hi
integer 7
integer 8
3.14
nil
error: boom
unhandled []int

Aturan yang perlu kamu tahu:

• Di case dengan satu tipe, x bertipe itu. Di case yang berisi beberapa tipe, dan di default, x bertipe interface aslinya (any di sini).
• Case diperiksa berurutan. Taruh interface yang lebih spesifik sebelum yang lebih umum, karena sebuah nilai bisa memenuhi beberapa interface.
• case nil hanya cocok dengan interface yang nil, bukan interface yang berisi pointer nil.
• Tidak ada fallthrough di type switch.

errors.As: assertion untuk error yang dibungkus

Error sering dibungkus dengan konteks: fmt.Errorf("load config: %w", err). Type assertion langsung hanya melihat error terluar dan melewatkan error di dalamnya. errors.As menelusuri rantainya.

package main

import (
	"errors"
	"fmt"
	"io/fs"
	"os"
)

func load() error {
	_, err := os.Open("/no/such/file")
	if err != nil {
		return fmt.Errorf("load config: %w", err)
	}
	return nil
}

func main() {
	err := load()

	_, ok := err.(*fs.PathError)
	fmt.Println("type assertion finds it:", ok)

	var pe *fs.PathError
	if errors.As(err, &pe) {
		fmt.Println("errors.As finds it:", pe.Op, pe.Path)
	}
}

Output:

type assertion finds it: false
errors.As finds it: open /no/such/file

Pakai type assertion pada error hanya kalau kamu tahu error-nya tidak dibungkus, yang dalam praktiknya hampir tidak pernah. Halaman custom error membahas errors.As, errors.Is, dan cara mendefinisikan tipe error sendiri.

Assertion vs konversi vs generic

Kode yang penuh any dan type switch sering menjadi tanda bahwa generic atau interface yang tepat akan menyatakan maksudnya dengan lebih baik dan menangkap kesalahan saat kompilasi.

Kesalahan umum

• Memakai bentuk yang bisa panic pada data yang tidak tepercaya. JSON hasil decode, nilai map bertipe any, input plugin: selalu pakai comma-ok.
• Assertion ke tipe angka yang salah. Angka JSON di-decode ke any sebagai float64, jadi v.(int) gagal pada angka itu.
• Assertion ke tipe nilai padahal yang disimpan adalah pointer. Kalau interface-nya berisi *User, maka v.(User) gagal. Lakukan assertion v.(*User).
• Type assertion pada error. Pakai errors.As.