Struct ב-Golang: הגדרה, אתחול, השוואה ו-tags

הגדרה ויצירה של struct

טיפוס struct הוא רשימה של שדות עם שמות. מצהירים עליו עם type Name struct { ... } ויוצרים ערכים עם ליטרל מורכב.

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

פלט:

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 מדפיס את שמות השדות ו-%#v מדפיס תחביר Go. שניהם הדרך המהירה ביותר לבדוק struct בזמן דיבוג.

שדות מאותו טיפוס יכולים לחלוק שורה: X, Y float64. שמות שדות שמתחילים באות גדולה מיוצאים (גלויים לחבילות אחרות ול-encoding/json); שמות באותיות קטנות לא.

צורות של ליטרלים

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

העדיפו שדות עם שמות. ליטרלים לפי מיקום נשברים כשמישהו מוסיף שדה או משנה את הסדר, ו-go vet מזהיר עליהם בטיפוסי struct מחבילות אחרות (למשל net/url.Error struct literal uses unkeyed fields). צורה לפי מיקום מתאימה לטיפוסים מקומיים זעירים כמו Point{1, 2}.

אין ערכי ברירת מחדל: ערכי אפס ובנאים

ל-Go אין ברירות מחדל לשדות ואין בנאים בשפה. כל שדה מתחיל בערך האפס של הטיפוס שלו: 0, "", false, nil. שני ניבים ממלאים את החסר.

הפכו את ערך האפס לשימושי. sync.Mutex, bytes.Buffer ו-strings.Builder כולם עובדים בלי אתחול. כשאפשר לתכנן טיפוס בצורה כזאת, עשו זאת.

כתבו פונקציית NewX כששדה צריך ברירת מחדל שאינה אפס או כשצריך להקצות משהו, כמו 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 מחזירה מצביע כי לשרת יש מתודות שמשנות אותו והוא יהיה משותף. גם החזרת ה-struct כערך נפוצה בטיפוסים קטנים ו-immutable (time.Date מחזירה time.Time).

מצביעים ל-structs

Go מבצעת dereference אוטומטי למצביעים ל-structs בגישה לשדות. עם p := &User{}, כותבים p.Name, לא (*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)
}

פלט:

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

structs הם ערכים. הצבה וארגומנטים של פונקציה מעתיקים אותם; מצביע משתף עותק אחד. העתקות שדה אחרי שדה הן רדודות: שדה של slice או map בעותק עדיין מצביע על אותם נתונים. ראו מצביעים כדי לדעת מתי להשתמש בכל אחד.

structs אנונימיים

אפשר לכתוב טיפוס struct בתוך השורה בלי שם. זה שימושי לקיבוצים חד פעמיים, לבדיקות מבוססות טבלה ולפענוח JSON שקוראים רק פעם אחת.

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

הטבלה []struct{ in string; want int } היא הצורה הסטנדרטית של בדיקה ב-Go.

השוואת structs

structs ניתנים להשוואה עם == כשכל שדה הוא comparable. שוויון פירושו שכל השדות שווים. structs שניתנים להשוואה יכולים לשמש גם כמפתחות של 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))
}

ל-struct עם שדות של slice או map, כתבו מתודת Equal או השוו בבדיקות עם reflect.DeepEqual.

Struct tags

tag הוא ליטרל מחרוזת אחרי הטיפוס של שדה. השפה מתעלמת ממנו; ספריות קוראות אותו עם reflection. הקורא הנפוץ ביותר הוא 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))
}

זה מדפיס {"id":7,"name":"Mug"}: ה-tag משנה את שמות השדות, omitempty משמיט את ה-Price שערכו אפס, והשדה שלא מיוצא בלתי נראה למקודד. tags עוקבים אחרי המוסכמה key:"value", עם כמה מפתחות שמופרדים ברווחים: `json:"name" db:"user_name"`. tag פגום מתקמפל בלי בעיה ופשוט מתעלמים ממנו בשקט, ו-go vet תופס את זה. הדף על json מכסה את האפשרויות.

structs ריקים וסדר השדות

ל-struct{} אין שדות והוא תופס אפס בתים. משתמשים בו כערך של set (map[string]struct{}) וכאות ב-channels (chan struct{}), שבהם רק האירוע חשוב.

סדר השדות משפיע על פריסת הזיכרון: המהדר מרפד שדות לפי היישור שלהם. struct של bool, int64, bool תופס 24 בתים במערכות 64 ביט, בעוד int64, bool, bool תופס 16. זה משנה רק בטיפוסים שנשמרים בכמויות גדולות.

טעויות נפוצות

• שינוי של עותק. for _, u := range users { u.Age++ } משנה עותק בכל פעם. השתמשו באינדקס: users[i].Age++.
• שכחה לאתחל שדה של map. ערך האפס של ה-struct מחזיק map שהוא nil; כתיבה אליו גורמת ל-panic. הקצו בבנאי.
• העתקת struct שמחזיק sync.Mutex. לעותק יש מצב נעילה משלו. העבירו structs כאלה לפי מצביע; go vet מדווח על ההעתקה.
• ליטרלים לפי מיקום לטיפוסים של חבילות אחרות. הם נשברים כשנוסף שדה.