Interface trong Golang: triển khai ngầm, any và bẫy nil

Interface là một tập phương thức

Một kiểu interface liệt kê các chữ ký phương thức (method). Kiểu nào có những phương thức đó thì thỏa mãn interface, mà không cần khai báo nào nói ra điều đó.

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

Cả Rect lẫn Circle đều không nhắc đến Shape. Đó là triển khai ngầm định, đặc điểm cốt lõi của interface trong Go. Nhờ vậy, bạn có thể định nghĩa trong package của mình một interface mà các kiểu từ package khác đã thỏa mãn sẵn, không cần đụng vào code của chúng.

Các interface nhỏ trong thư viện chuẩn

Code Go ưa chuộng interface chỉ có một hoặc hai phương thức. Những interface quan trọng nhất:

Vì io.Reader chỉ có một phương thức, hàng chục kiểu triển khai nó, và hàm nào nhận một io.Reader cũng làm việc được với tất cả các kiểu đó:

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

Câu tục ngữ của Go là "interface càng lớn, trừu tượng càng yếu". Interface lớn hơn được xây bằng cách ghép các interface nhỏ: io.ReadWriter là Reader cộng Writer, viết bằng cách nhúng một interface vào interface khác.

any: interface rỗng

interface{} không có phương thức nào, nên mọi kiểu đều thỏa mãn nó. Go 1.18 thêm any làm alias; hai cái hoàn toàn giống nhau.

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

Một giá trị any chứa được mọi thứ nhưng bạn gần như không làm được gì với nó cho đến khi lấy lại kiểu cụ thể bằng type assertion hoặc type switch. Hãy ưu tiên một interface thật hoặc generics khi đã biết tập các kiểu. any hợp với dữ liệu thật sự động, như JSON đã giải mã mà không biết trước cấu trúc, và với việc in ra.

Một giá trị interface chứa gì

Một giá trị interface là một cặp: kiểu động và giá trị động. var s Shape = Rect{3, 4} lưu kiểu Rect và một bản sao của giá trị. Gọi s.Area() sẽ tra phương thức của Rect lúc chạy.

Một interface chỉ là nil khi cả hai phần đều trống. Quy tắc đó gây ra bug khó hiểu nhất trong Go.

Bẫy interface nil

Một con trỏ nil được lưu trong interface tạo ra một interface khác 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
}

Đầu ra:

false
*main.MyError true
true

validate(true) trả về một interface error chứa kiểu *MyError và giá trị nil. Interface đó có kiểu, nên nó không bằng nil, và nhánh if err != nil của nơi gọi được chạy. Gọi err.Error() ở đó sẽ gây panic khi truy cập trường của receiver nil.

Cách sửa rất đơn giản: khai báo biến với kiểu error, không phải kiểu con trỏ cụ thể, hoặc trả về nil trực tiếp ở nhánh thành công. Đừng bao giờ trả về một kiểu con trỏ lỗi cụ thể từ hàm có kết quả là error. Cái bẫy này áp dụng cho mọi interface, không chỉ lỗi.

Kiểm tra một kiểu có triển khai interface không

Việc triển khai được kiểm tra ở chỗ một giá trị được gán cho interface. Nếu chưa có code nào làm vậy, một lỗi trong chữ ký phương thức sẽ không bị phát hiện. Một phép gán rỗng ở cấp package giúp việc kiểm tra trở nên rõ ràng:

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

Việc này không tốn gì lúc chạy. Nếu *LogWriter có Write(p []byte) error thay vì Write(p []byte) (int, error), quá trình build thất bại:

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 và interface

Nếu một phương thức có pointer receiver, chỉ kiểu con trỏ mới có phương thức đó. *Counter thỏa mãn interface nhờ nó; Counter thì không. Trình biên dịch báo Counter does not implement Incrementer (method Inc has pointer receiver). Hãy lưu &Counter{} vào interface. Trang phương thức giải thích về method set.

Nhận interface, trả về struct

Một nguyên tắc phổ biến trong Go: hàm nên nhận tham số là interface và trả về kiểu cụ thể.

• Nhận một interface cho phép nơi gọi truyền vào bất cứ thứ gì phù hợp, kể cả đối tượng giả trong test. Một hàm đọc dữ liệu nên nhận io.Reader, không phải *os.File.
• Trả về một kiểu cụ thể cho phép nơi gọi dùng mọi phương thức và trường của nó, và tránh được bẫy interface nil. os.Open trả về *os.File, không phải io.Reader.

Một thói quen liên quan: định nghĩa interface ở nơi dùng nó, không phải ở nơi triển khai nó. Nếu service của bạn cần thứ gì đó có thể Get(id) một người dùng, hãy khai báo một interface một phương thức trong package của service, và để package cơ sở dữ liệu chỉ cần export struct của nó.

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

So sánh các giá trị interface

Hai giá trị interface bằng nhau khi kiểu động của chúng giống hệt nhau và giá trị động bằng nhau. Nếu kiểu động không so sánh được (một slice, một map), == vẫn biên dịch được nhưng gây panic lúc chạy: runtime error: comparing uncomparable type []int.

Lỗi thường gặp

• Trả về một con trỏ nil có kiểu dưới dạng interface. Hãy trả về nil trực tiếp.
• Tạo interface quá sớm. Hãy viết kiểu cụ thể trước. Thêm interface khi có cách triển khai thứ hai hoặc khi test cần đến.
• Con trỏ tới interface. *io.Reader gần như không bao giờ đúng. Một interface vốn đã giữ con trỏ khi bạn lưu con trỏ vào nó.
• Interface lớn. Interface mười phương thức khó triển khai và khó làm giả. Hãy tách chúng ra.