Struct trong Golang: khai báo, khởi tạo, so sánh và tag

Khai báo và tạo struct

Một kiểu struct là danh sách các trường có tên. Bạn khai báo nó bằng type Name struct { ... } và tạo giá trị bằng composite literal.

package main

import "fmt"

type User struct {
	Name  string
	Email string
	Age   int
	Admin bool
}

func main() {
	a := User{Name: "Ana", Email: "ana@example.com", Age: 31}
	fmt.Println(a.Name, a.Age)

	a.Age++ // fields are accessed and set with a dot
	fmt.Printf("%+v\n", a)

	var b User // zero value: every field at its own zero
	fmt.Printf("%+v\n", b)
	fmt.Printf("%#v\n", User{Name: "Bob"})
}

Đầu ra:

Ana 31
{Name:Ana Email:ana@example.com Age:32 Admin:false}
{Name: Email: Age:0 Admin:false}
main.User{Name:"Bob", Email:"", Age:0, Admin:false}

%+v in tên trường còn %#v in theo cú pháp Go. Cả hai là cách nhanh nhất để xem một struct khi gỡ lỗi.

Các trường cùng kiểu có thể viết chung một dòng: X, Y float64. Tên trường viết hoa chữ đầu được export (nhìn thấy từ package khác và từ encoding/json); tên viết thường thì không.

Các dạng literal

User{Name: "Ana", Age: 31}        // named fields: order-free, omitted fields are zero
User{"Ana", "a@x.com", 31, false} // positional: every field, in order
&User{Name: "Ana"}                // pointer to a new struct
new(User)                         // pointer to a zeroed struct

Nên dùng tên trường. Literal theo vị trí sẽ hỏng khi có người thêm trường hoặc đổi thứ tự trường, và go vet cảnh báo về chúng với kiểu struct từ package khác (ví dụ net/url.Error struct literal uses unkeyed fields). Dạng theo vị trí vẫn ổn với các kiểu cục bộ rất nhỏ như Point{1, 2}.

Không có giá trị mặc định: giá trị zero và hàm khởi tạo

Go không có giá trị mặc định cho trường và ngôn ngữ cũng không có hàm khởi tạo. Mọi trường bắt đầu ở giá trị zero của kiểu: 0, "", false, nil. Có hai cách viết chuẩn để bù vào.

Làm cho giá trị zero dùng được. sync.Mutex, bytes.Buffer và strings.Builder đều hoạt động mà không cần khởi tạo. Khi có thể thiết kế kiểu theo cách đó, hãy làm vậy.

Viết hàm NewX khi một trường cần giá trị mặc định khác zero hoặc có thứ cần cấp phát, như một map:

package main

import (
	"fmt"
	"time"
)

type Server struct {
	Addr    string
	Timeout time.Duration
	routes  map[string]string
}

func NewServer(addr string) *Server {
	return &Server{
		Addr:    addr,
		Timeout: 30 * time.Second,
		routes:  make(map[string]string),
	}
}

func (s *Server) Handle(path, name string) {
	s.routes[path] = name
}

func main() {
	s := NewServer(":8080")
	s.Handle("/", "index")
	fmt.Println(s.Addr, s.Timeout, len(s.routes))
}

NewServer trả về con trỏ vì server có các phương thức thay đổi nó và sẽ được dùng chung. Trả về struct theo giá trị cũng phổ biến với các kiểu nhỏ, bất biến (time.Date trả về một time.Time).

Con trỏ tới struct

Go tự động dereference con trỏ struct khi truy cập trường. Với p := &User{}, bạn viết p.Name, không phải (*p).Name.

package main

import "fmt"

type Point struct{ X, Y int }

func moveBy(p *Point, dx, dy int) {
	p.X += dx
	p.Y += dy
}

func main() {
	pt := Point{1, 2}
	moveBy(&pt, 10, 10)
	fmt.Println(pt)

	copyPt := pt // a struct assignment copies every field
	copyPt.X = 0
	fmt.Println(pt, copyPt)

	alias := &pt // a pointer shares the same struct
	alias.Y = 0
	fmt.Println(pt)
}

Đầu ra:

{11 12}
{11 12} {0 12}
{11 0}

Struct là giá trị. Phép gán và đối số hàm sao chép chúng; con trỏ thì dùng chung một bản. Sao chép từng trường là sao chép nông: trường slice hay map trong bản sao vẫn trỏ tới cùng dữ liệu. Xem trang con trỏ để biết khi nào dùng cách nào.

Struct ẩn danh

Một kiểu struct có thể viết trực tiếp tại chỗ mà không cần tên. Cách này hữu ích cho những nhóm dữ liệu dùng một lần, test dạng bảng và giải mã JSON chỉ đọc một lần.

package main

import "fmt"

func main() {
	point := struct {
		X, Y int
	}{3, 4}
	fmt.Println(point.X, point.Y)

	tests := []struct {
		in   string
		want int
	}{
		{"go", 2},
		{"gopher", 6},
	}
	for _, tc := range tests {
		fmt.Println(tc.in, len(tc.in) == tc.want)
	}
}

Bảng []struct{ in string; want int } là dạng chuẩn của một bài test trong Go.

So sánh struct

Struct so sánh được bằng == khi mọi trường đều so sánh được. Bằng nhau nghĩa là tất cả các trường bằng nhau. Struct so sánh được cũng có thể làm khóa của map.

package main

import (
	"fmt"
	"slices"
)

type Point struct{ X, Y int }

type Polygon struct {
	Name   string
	Points []Point // slices make the struct incomparable
}

func main() {
	fmt.Println(Point{1, 2} == Point{1, 2})

	grid := map[Point]string{{0, 0}: "origin"}
	fmt.Println(grid[Point{0, 0}])

	a := Polygon{"tri", []Point{{0, 0}, {1, 0}, {0, 1}}}
	b := Polygon{"tri", []Point{{0, 0}, {1, 0}, {0, 1}}}
	// fmt.Println(a == b) // compile error: struct containing []Point cannot be compared
	fmt.Println(a.Name == b.Name && slices.Equal(a.Points, b.Points))
}

Với struct có trường slice hoặc map, hãy viết phương thức Equal hoặc so sánh trong test bằng reflect.DeepEqual.

Struct tag

Tag là một literal chuỗi đặt sau kiểu của trường. Ngôn ngữ bỏ qua nó; các thư viện đọc nó bằng reflection. Nơi đọc tag phổ biến nhất là encoding/json:

package main

import (
	"encoding/json"
	"fmt"
)

type Product struct {
	ID       int     `json:"id"`
	Name     string  `json:"name"`
	Price    float64 `json:"price,omitempty"`
	internal string  // unexported: never encoded
}

func main() {
	out, err := json.Marshal(Product{ID: 7, Name: "Mug", internal: "x"})
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(string(out))
}

Chương trình in ra {"id":7,"name":"Mug"}: tag đổi tên trường, omitempty bỏ Price có giá trị zero, và trường không export thì bộ mã hóa không nhìn thấy. Tag theo quy ước key:"value", nhiều khóa cách nhau bằng dấu cách: `json:"name" db:"user_name"`. Một tag sai định dạng vẫn biên dịch được và bị bỏ qua mà không báo gì, go vet sẽ phát hiện lỗi này. Trang json giải thích các tùy chọn.

Struct rỗng và thứ tự trường

struct{} không có trường nào và chiếm 0 byte. Nó được dùng làm giá trị của set (map[string]struct{}) và làm tín hiệu trên channel (chan struct{}), nơi chỉ sự kiện là quan trọng.

Thứ tự trường ảnh hưởng tới cách bố trí bộ nhớ: trình biên dịch chèn đệm để các trường thẳng hàng theo căn chỉnh. Một struct gồm bool, int64, bool chiếm 24 byte trên hệ 64 bit, còn int64, bool, bool chiếm 16 byte. Điều này chỉ quan trọng với các kiểu được lưu với số lượng lớn.

Lỗi thường gặp

• Sửa trên bản sao. for _, u := range users { u.Age++ } mỗi lần chỉ thay đổi một bản sao. Hãy dùng chỉ số: users[i].Age++.
• Quên khởi tạo trường map. Giá trị zero của struct chứa một map nil; ghi vào nó sẽ panic. Hãy cấp phát trong hàm khởi tạo.
• Sao chép struct chứa sync.Mutex. Bản sao có trạng thái khóa riêng. Truyền những struct như vậy bằng con trỏ; go vet sẽ báo việc sao chép.
• Literal theo vị trí cho kiểu của package khác. Chúng sẽ hỏng khi có trường mới được thêm vào.