Type assertion trong Golang: x.(T), comma-ok và type switch

x.(T): lấy giá trị ra khỏi interface

Một giá trị interface che đi kiểu cụ thể mà nó đang chứa. Type assertion x.(T) yêu cầu lấy lại kiểu đó.

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))
	}
}

Đầu ra:

gopher 6
0 false
string of length 6

x phải có kiểu interface. Assert trên một kiểu cụ thể sẽ không biên dịch được: invalid operation: s (variable of type string) is not an interface.

Dạng một giá trị sẽ panic

Khi assertion sai, dạng một giá trị panic với thông báo nêu tên cả hai kiểu:

package main

import "fmt"

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

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

Đầu ra:

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

Chỉ dùng dạng một giá trị khi một kiểu khác xuất hiện là lỗi lập trình mà bạn muốn chương trình dừng ngay. Mọi chỗ khác, hãy dùng comma-ok. Khi thất bại, comma-ok trả về giá trị zero của T và false.

Assert trên một interface nil cũng thất bại: var v any; v.(string) panic với interface conversion: interface {} is nil, not string, còn dạng comma-ok trả về "", false.

Assert sang một interface khác

T có thể là kiểu interface. Khi đó assertion thành công nếu giá trị động implement T, và kết quả vẫn giữ nguyên giá trị động đó. Thư viện chuẩn dùng cách này để kiểm tra các khả năng tùy chọn.

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 kiểm tra xem nguồn có implement io.WriterTo không và dùng nó nếu có. fmt kiểm tra Stringer và error. Mẫu này cho phép một interface nhỏ giữ nguyên nhỏ gọn, trong khi nơi gọi vẫn hưởng lợi từ những cài đặt phong phú hơn.

Type switch

Khi một giá trị có thể là một trong nhiều kiểu, type switch thay cho cả chuỗi assertion. x.(type) chỉ hợp lệ bên trong một 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))
	}
}

Đầu ra:

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

Những quy tắc nên biết:

• Trong case chỉ có một kiểu, x mang kiểu đó. Trong case liệt kê nhiều kiểu, và trong default, x mang kiểu của interface ban đầu (ở đây là any).
• Các case được kiểm tra theo thứ tự. Đặt interface cụ thể hơn trước interface rộng hơn, vì một giá trị có thể thỏa mãn nhiều interface.
• case nil chỉ khớp với interface nil, không khớp với interface đang chứa một con trỏ nil.
• Type switch không có fallthrough.

errors.As: assertion cho lỗi được bọc

Lỗi thường được bọc thêm ngữ cảnh: fmt.Errorf("load config: %w", err). Type assertion trực tiếp chỉ nhìn vào lỗi ở lớp ngoài cùng và bỏ sót lỗi bên trong. errors.As đi dọc cả chuỗi.

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)
	}
}

Đầu ra:

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

Chỉ dùng type assertion với lỗi khi bạn chắc chắn lỗi không bị bọc, mà trên thực tế gần như không bao giờ. Trang lỗi tùy chỉnh trình bày errors.As, errors.Is và cách định nghĩa kiểu lỗi của riêng bạn.

Assertion, chuyển đổi kiểu hay generics

Code đầy any và type switch thường là dấu hiệu cho thấy generics hoặc một interface đúng nghĩa sẽ diễn đạt ý định rõ hơn và bắt lỗi ngay lúc biên dịch.

Lỗi thường gặp

• Dùng dạng gây panic với dữ liệu không đáng tin. JSON đã decode, giá trị map kiểu any, đầu vào từ plugin: luôn dùng comma-ok.
• Assert sai kiểu số. Số trong JSON được decode vào any thành float64, nên v.(int) thất bại với chúng.
• Assert kiểu giá trị khi bên trong là con trỏ. Nếu interface chứa *User thì v.(User) thất bại. Hãy assert v.(*User).
• Dùng type assertion với lỗi. Hãy dùng errors.As.