Struct Literal

Mengisi struct field demi field lewat assignment terasa membosankan ketika data sudah diketahui sejak awal. Go menyediakan struct literal — ekspresi yang sekaligus membuat nilai struct dan mengisi field-nya. Ada dua gaya penulisan: keyed yang menyebut nama field dan positional yang mengandalkan urutan field. Pada chapter ini kita coba kedua gaya, literal yang mengisi sebagian field, literal pointer &Titik{...}, serta literal bersarang di dalam slice dan map.

Literal Keyed (Disarankan) #

Literal keyed menyebut nama setiap field yang diisi, seperti Titik{X: 1, Y: 2}. Tiga keunggulan membuat gaya ini menjadi standar industri: urutan penulisan field bebas, field yang tidak disebut otomatis berisi zero value, dan pembaca kode langsung tahu nilai mana milik field mana. Ketika definisi struct berubah — field ditambah atau diurut ulang — literal keyed tetap dikompilasi tanpa perubahan.

Literal Positional dan Bahayanya #

Literal positional mengisi field berdasarkan urutan deklarasi: Titik{3, 4} berarti X bernilai 3 dan Y bernilai 4. Bentuk ini ringkas, tetapi rapuh: seluruh field wajib diisi sesuai urutan, dan setiap perubahan definisi struct berpotensi menggeser makna nilai tanpa terdeteksi. Jika sebuah field baru ditambahkan di tengah struct, Titik{3, 4} langsung gagal dikompilasi.

Literal Sebagian Keyed #

Literal keyed boleh mengisi sebagian field saja; sisanya berisi zero value. Ekspresi Titik{X: 9} menghasilkan struct dengan X bernilai 9 dan Y bernilai 0. Kombinasi literal sebagian dan desain struct yang zero value-nya bermakna memungkinkan kita menulis hanya field yang relevan.

Pointer Literal &Titik #

Menulis & sebelum literal menghasilkan pointer ke struct baru: d := &Titik{X: 5, Y: 6} memberi d bertipe *Titik. Bentuk ini setara dengan new(Titik) lalu mengisi tiap field, tetapi ditulis dalam satu ekspresi. Ketika dicetak dengan fmt.Println, pointer struct tampil sebagai &{5 6} — tanda & menandai pointer dan isi struct tetap terlihat.

Literal Bersarang dalam Slice dan Map #

Nilai struct sering dikumpulkan dalam slice atau map. Go mempersingkat penulisannya: di dalam literal slice []Titik atau literal map, nama tipe elemen boleh dihilangkan menjadi {...}. Perhatikan bahwa setiap elemen tetap bebas memilih gaya — []Titik{{1, 2}, {3, 4}, {X: 5}} menggabungkan elemen positional dan keyed dalam satu slice.

Program Utuh #

Berkas literal-demo.go mempraktikkan seluruh bentuk literal dalam satu program:

package main

import "fmt"

type Titik struct {
	X int
	Y int
}

func main() {
	a := Titik{X: 1, Y: 2}
	b := Titik{3, 4}
	c := Titik{X: 9}
	d := &Titik{X: 5, Y: 6}

	fmt.Println(a, b, c, d)
	fmt.Println(a.X, b.X, c.X, d.X)

	deret := []Titik{{1, 2}, {3, 4}, {X: 5}}
	fmt.Println(deret)

	arah := map[string]Titik{
		"asal":       {X: 0, Y: 0},
		"kanan-atas": {X: 10, Y: 10},
	}
	fmt.Println(arah)
}

Jalankan program dari direktori chapter:

go run literal-demo.go

Output yang Dihasilkan:

{1 2} {3 4} {9 0} &{5 6}
1 3 9 5
[{1 2} {3 4} {5 0}]
map[asal:{0 0} kanan-atas:{10 10}]

Mari kita telaah baris demi baris program di atas:

1. Baris 11 (a := Titik{X: 1, Y: 2}): membuat struct dengan literal keyed — urutan field bebas dan makna tiap nilai jelas.
2. Baris 12 (b := Titik{3, 4}): membuat struct dengan literal positional — nilai 3 masuk ke field pertama X dan 4 ke field kedua Y berdasarkan urutan deklarasi.
3. Baris 13 (c := Titik{X: 9}): mengisi satu field saja; field Y dibiarkan berisi zero value 0, terlihat dari cetakan {9 0}.
4. Baris 14 (d := &Titik{X: 5, Y: 6}): membuat pointer ke struct baru; cetakan &{5 6} pada baris pertama output menandakan d bertipe *Titik.
5. Baris 17 (a.X, b.X, c.X, d.X): mengakses field dari keempat variabel — akses melalui pointer d.X berjalan otomatis tanpa operator khusus.
6. Baris 19–20 (deret := []Titik{...}): membangun slice berisi tiga struct dengan tipe elemen dihilangkan; elemen ketiga memakai gaya keyed sehingga Y-nya nol.
7. Baris 22–26 (arah := map[string]Titik{...}): membangun map dari string ke struct; fmt.Println mengurutkan kunci map saat mencetak sehingga output tetap terurut dan deterministik.

Referensi #

• Effective Go: Composite literals — anjuran resmi gaya penulisan literal.
• Effective Go: Composite types — struktur data komposit termasuk array dan slice.
• Dokumentasi package fmt — format cetakan struct dan map.

package main

import "fmt"

type Titik struct {
	X int
	Y int
}

func main() {
	a := Titik{X: 1, Y: 2}
	b := Titik{3, 4}
	c := Titik{X: 9}
	d := &Titik{X: 5, Y: 6}

	fmt.Println(a, b, c, d)
	fmt.Println(a.X, b.X, c.X, d.X)

	deret := []Titik{{1, 2}, {3, 4}, {X: 5}}
	fmt.Println(deret)

	arah := map[string]Titik{
		"asal":       {X: 0, Y: 0},
		"kanan-atas": {X: 10, Y: 10},
	}
	fmt.Println(arah)
}