Struct di Golang: Mendefinisikan, Menginisialisasi, Membandingkan, dan Tag

Mendefinisikan dan membuat struct

Tipe struct adalah daftar field bernama. Kamu mendeklarasikannya dengan type Name struct { ... } dan membuat nilainya dengan 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"})
}

Output:

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 mencetak nama field dan %#v mencetak sintaks Go. Keduanya adalah cara tercepat untuk memeriksa isi struct saat debugging.

Field dengan tipe yang sama bisa ditulis dalam satu baris: X, Y float64. Nama field yang diawali huruf besar diekspor (terlihat oleh package lain dan oleh encoding/json); nama yang diawali huruf kecil tidak.

Bentuk 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

Pakai nama field. Literal posisional rusak ketika seseorang menambah atau mengubah urutan field, dan go vet memberi peringatan untuk literal posisional pada tipe struct dari package lain (misalnya net/url.Error struct literal uses unkeyed fields). Bentuk posisional boleh dipakai untuk tipe lokal yang sangat kecil seperti Point{1, 2}.

Tidak ada nilai default: zero value dan constructor

Go tidak punya nilai default untuk field dan tidak punya constructor di level bahasa. Setiap field dimulai dari zero value tipenya: 0, "", false, nil. Ada dua kebiasaan untuk mengisi kekosongan itu.

Buat zero value-nya berguna. sync.Mutex, bytes.Buffer, dan strings.Builder semuanya bisa dipakai tanpa inisialisasi. Kalau kamu bisa merancang tipe seperti itu, lakukan.

Tulis fungsi NewX saat sebuah field butuh nilai default yang bukan nol, atau ada sesuatu yang harus dialokasikan, seperti 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 mengembalikan pointer karena server punya method yang mengubahnya dan akan dipakai bersama. Mengembalikan struct sebagai nilai juga umum untuk tipe kecil yang immutable (time.Date mengembalikan time.Time).

Pointer ke struct

Go otomatis melakukan dereference pada pointer struct saat mengakses field. Dengan p := &User{}, kamu menulis p.Name, bukan (*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)
}

Output:

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

Struct adalah nilai. Assignment dan argumen fungsi menyalinnya; pointer membaginya. Salinan field demi field bersifat dangkal: field slice atau map di salinan tetap menunjuk ke data yang sama. Lihat pointer untuk tahu kapan memakai yang mana.

Anonymous struct

Tipe struct bisa ditulis langsung tanpa nama. Ini berguna untuk pengelompokan sekali pakai, table-driven test, dan decode JSON yang hanya kamu baca sekali.

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

Tabel []struct{ in string; want int } adalah bentuk standar sebuah tes di Go.

Membandingkan struct

Struct bisa dibandingkan dengan == jika setiap field-nya bisa dibandingkan. Sama berarti semua field-nya sama. Struct yang bisa dibandingkan juga bisa dipakai sebagai key 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))
}

Untuk struct dengan field slice atau map, tulis method Equal, atau bandingkan di tes dengan reflect.DeepEqual.

Struct tag

Tag adalah string literal setelah tipe sebuah field. Bahasa Go mengabaikannya; library membacanya dengan reflection. Pembaca yang paling umum adalah 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))
}

Program ini mencetak {"id":7,"name":"Mug"}: tag mengganti nama field, omitempty membuang Price yang bernilai nol, dan field yang tidak diekspor tidak terlihat oleh encoder. Tag mengikuti konvensi key:"value", dengan beberapa key dipisahkan spasi: `json:"name" db:"user_name"`. Tag yang formatnya salah tetap bisa dikompilasi dan diabaikan diam-diam, dan go vet bisa menangkapnya. Halaman JSON membahas opsi-opsinya.

Struct kosong dan urutan field

struct{} tidak punya field dan memakan nol byte. Struct ini dipakai sebagai nilai set (map[string]struct{}) dan sebagai sinyal di channel (chan struct{}), saat yang penting hanya kejadiannya.

Urutan field memengaruhi tata letak memori: compiler menambahkan padding agar setiap field sesuai alignment-nya. Struct berisi bool, int64, bool memakan 24 byte di sistem 64-bit, sedangkan int64, bool, bool memakan 16. Hal ini hanya penting untuk tipe yang disimpan dalam jumlah besar.

Kesalahan umum

• Mengubah salinan. for _, u := range users { u.Age++ } mengubah salinan setiap kali. Pakai indeksnya: users[i].Age++.
• Lupa menginisialisasi field map. Zero value struct berisi map nil; menulis ke map itu akan panic. Alokasikan di constructor.
• Menyalin struct yang berisi sync.Mutex. Salinannya punya status kunci sendiri. Kirim struct seperti itu lewat pointer; go vet melaporkan penyalinannya.
• Literal posisional untuk tipe dari package lain. Literal itu rusak saat ada field yang ditambahkan.