Nhúng struct Golang: embedding và phương thức được nâng

Embedding qua một ví dụ

Một trường có kiểu nhưng không có tên là trường được nhúng (embedded field). Các trường và phương thức của kiểu được nhúng trở nên truy cập được trực tiếp trên kiểu bên ngoài.

package main

import "fmt"

type User struct {
	Name  string
	Email string
}

func (u User) Greet() string {
	return "Hi, I'm " + u.Name
}

type Admin struct {
	User  // embedded: no field name
	Level int
}

func main() {
	a := Admin{
		User:  User{Name: "Ana", Email: "ana@example.com"},
		Level: 2,
	}

	fmt.Println(a.Name)       // promoted field
	fmt.Println(a.Greet())    // promoted method
	fmt.Println(a.User.Email) // the explicit path still works
	fmt.Printf("%+v\n", a)
}

Đầu ra:

Ana
Hi, I'm Ana
ana@example.com
{User:{Name:Ana Email:ana@example.com} Level:2}

Tên của trường được nhúng chính là tên kiểu của nó, User. Đó là cách bạn gọi nó trong literal (User: User{...}) và khi cần chính giá trị bên trong (a.User). Không thể gán một trường được nâng bằng tên ngắn của nó trong literal: Admin{Name: "Ana"} báo lỗi unknown field Name in struct literal of type Admin.

Phương thức được nâng thỏa mãn interface

Việc nâng thêm các phương thức của kiểu được nhúng vào tập phương thức của kiểu bên ngoài. Vì vậy kiểu bên ngoài thỏa mãn mọi interface mà kiểu bên trong thỏa mãn.

package main

import "fmt"

type Logger struct {
	prefix string
}

func (l *Logger) Log(msg string) {
	fmt.Println(l.prefix + msg)
}

type Service struct {
	*Logger // embedded pointer
	name    string
}

type Loggable interface {
	Log(string)
}

func main() {
	svc := &Service{
		Logger: &Logger{prefix: "[billing] "},
		name:   "billing",
	}
	svc.Log("started")

	var l Loggable = svc // *Service has Log through the embedded *Logger
	l.Log("via interface")
}

Quy tắc về tập phương thức đi theo kiểu được nhúng. Nhúng T sẽ nâng các phương thức có receiver giá trị của T lên cả giá trị lẫn con trỏ của kiểu bên ngoài, nhưng các phương thức có receiver con trỏ của *T chỉ được nâng lên con trỏ của kiểu bên ngoài. Nhúng *T thì nâng cả hai tập lên cả hai. Nếu phân vân, hãy nhúng con trỏ, hoặc dùng kiểu bên ngoài qua con trỏ.

Nhúng con trỏ có cái giá của nó: con trỏ có thể là nil. Service{} không có Logger vẫn biên dịch được, và khi đó svc.Log(...) sẽ panic.

Embedding không phải kế thừa

Embedding trông giống tạo lớp con, nhưng có ba điểm hoạt động khác với Java hay Python.

Kiểu bên ngoài không phải là kiểu bên trong. Admin không phải là User. Một hàm nhận User sẽ không chấp nhận Admin; hãy truyền a.User.

Không có virtual dispatch. Phương thức được nâng chạy trên giá trị được nhúng, và nó không biết gì về kiểu bên ngoài. Nếu nó gọi một phương thức khác, nó gọi phiên bản của chính kiểu nó, kể cả khi kiểu bên ngoài định nghĩa một phương thức cùng tên.

package main

import "fmt"

type Animal struct{}

func (Animal) Sound() string { return "..." }

func (a Animal) Speak() string {
	return "The animal says " + a.Sound() // always Animal.Sound
}

type Dog struct {
	Animal
}

func (Dog) Sound() string { return "woof" }

func main() {
	d := Dog{}
	fmt.Println(d.Sound()) // Dog's own method shadows the promoted one
	fmt.Println(d.Speak()) // promoted Speak calls Animal.Sound, not Dog.Sound
}

Đầu ra:

woof
The animal says ...

Trong ngôn ngữ dựa trên lớp, Speak sẽ in ra "woof". Trong Go, d.Speak() là cách viết tắt của d.Animal.Speak(), và receiver của lời gọi đó là Animal. Khi muốn hành vi thay đổi theo kiểu, hãy dùng interface: truyền một Sounder vào đoạn code cần nó.

Kiểu bên trong không biết mình đang được nhúng. Không có super. Để mở rộng một phương thức được nâng, hãy định nghĩa phương thức cùng tên trên kiểu bên ngoài và gọi tường minh phương thức bên trong:

func (a Admin) Greet() string {
	return a.User.Greet() + " (admin)"
}

Xung đột tên và che khuất

Một trường hay phương thức trên kiểu bên ngoài sẽ che khuất trường hay phương thức được nâng cùng tên, như Dog.Sound ở trên. Tên ở tầng nông hơn sẽ thắng.

Khi hai kiểu được nhúng ở cùng độ sâu cùng nâng một tên, tên đó trở nên mơ hồ. Chương trình vẫn biên dịch được miễn là không chỗ nào dùng tên mơ hồ đó:

package main

import "fmt"

type Reader struct{ ID int }
type Writer struct{ ID int }

type ReadWriter struct {
	Reader
	Writer
}

func main() {
	rw := ReadWriter{Reader{1}, Writer{2}}
	// fmt.Println(rw.ID) // compile error: ambiguous selector rw.ID
	fmt.Println(rw.Reader.ID, rw.Writer.ID)
}

Giải quyết xung đột bằng cách dùng đường dẫn đầy đủ, hoặc định nghĩa ID trên kiểu bên ngoài.

Nhúng interface

Interface có thể nhúng các interface khác. Thư viện chuẩn dựng các interface lớn hơn theo cách này:

type ReadWriter interface {
	Reader
	Writer
}

Struct cũng có thể nhúng một interface. Khi đó struct thỏa mãn interface đó thông qua giá trị bạn lưu trong trường, và bạn chỉ ghi đè những phương thức mình quan tâm. Đây là mẫu decorator với gần như không tốn code:

package main

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

// countingReader wraps any io.Reader and counts bytes read.
type countingReader struct {
	io.Reader
	n int
}

func (c *countingReader) Read(p []byte) (int, error) {
	n, err := c.Reader.Read(p) // call the wrapped reader
	c.n += n
	return n, err
}

func main() {
	cr := &countingReader{Reader: strings.NewReader("hello, embedding")}
	data, err := io.ReadAll(cr)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(string(data), cr.n)
}

Lời gọi tường minh c.Reader.Read(p) là bắt buộc. Viết c.Read(p) bên trong Read sẽ tự gọi chính nó mãi mãi.

Nhúng interface vào một đối tượng giả trong test là lối tắt hay dùng: nhúng interface lớn, cài đặt đúng một phương thức test cần, và bỏ qua phần còn lại. Phương thức nào chưa cài đặt mà bị gọi sẽ gây panic do dereference con trỏ nil, thường đó lại là điều bạn muốn trong test.

Một công dụng thực tế phổ biến: nhúng sync.Mutex

type Stats struct {
	sync.Mutex
	hits map[string]int
}

func (s *Stats) Hit(page string) {
	s.Lock()
	defer s.Unlock()
	s.hits[page]++
}

Cách này đọc dễ, nhưng nó cũng xuất Lock và Unlock thành một phần API của Stats, nên nơi gọi nào cũng có thể khóa struct của bạn. Với kiểu dùng bên ngoài package, một trường có tên (mu sync.Mutex) giữ khóa ở chế độ riêng tư. Sự đánh đổi này áp dụng cho mọi trường hợp embedding: mọi thứ kiểu được nhúng xuất ra đều trở thành một phần giao diện công khai của kiểu bạn.

Lỗi thường gặp

• Mong đợi virtual dispatch. Phương thức được nâng không bao giờ gọi các bản ghi đè của kiểu bên ngoài.
• Gán trường được nâng trong literal. Hãy dùng tên kiểu được nhúng: Admin{User: User{Name: "Ana"}}.
• Con trỏ được nhúng là nil. *T hay interface được nhúng phải được gán trước khi gọi phương thức của nó.
• Vô tình mở rộng API. Embedding xuất mọi phương thức được export của kiểu bên trong lên kiểu của bạn.