Go Academy · Pelajaran

Struct Anonim dan Komposisi

Embedding dan penggunaan ulang kode berbasis struct

Struct Anonim dan Komposisi adalah pelajaran Go Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Go Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Go Academy mencakup 4 pelajaran total.

Struktur Anonim

Struktur anonim tidak memiliki tipe bernama. Struktur ini ditentukan secara langsung dan berguna untuk data berumur singkat, pengujian berbasis tabel, serta pengelompokan sekali pakai:

package main
import "fmt"

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

Struktur Anonim dalam Pengujian Berbasis Tabel

Idiom Go yang umum menggunakan irisan struktur anonim untuk pengujian berbasis tabel:

package main
import "fmt"

func double(n int) int { return n * 2 }

func main() {
    tests := []struct{ input, want int }{
        {1, 2}, {5, 10}, {0, 0},
    }
    for _, tt := range tests {
        got := double(tt.input)
        if got != tt.want {
            fmt.Printf("FAIL: double(%d) = %d, want %d\n", tt.input, got, tt.want)
        }
    }
    fmt.Println("all tests passed")
}

Penyematan Tipe dalam Struktur

Menyematkan tipe di dalam struktur membuat anggota dan metodenya tersedia pada struktur luar:

package main
import "fmt"

type Animal struct{ Name string }
func (a Animal) Speak() string { return a.Name + " speaks" }

type Dog struct {
    Animal        // embedded
    Breed string
}

func main() {
    d := Dog{Animal: Animal{"Rex"}, Breed: "Labrador"}
    fmt.Println(d.Name)    // promoted field
    fmt.Println(d.Speak()) // promoted method
}

Penyematan Ganda

Struktur dapat menyematkan beberapa tipe. Konflik, seperti nama anggota atau metode yang sama, harus diselesaikan secara eksplisit:

package main
import "fmt"

type Logger struct{}
func (Logger) Log(s string) { fmt.Println("[LOG]", s) }

type Metrics struct{}
func (Metrics) Count() int { return 42 }

type Service struct {
    Logger
    Metrics
    Name string
}

func main() {
    svc := Service{Name: "auth"}
    svc.Log("started")       // from Logger
    fmt.Println(svc.Count()) // from Metrics
}

Penyematan dibandingkan Pewarisan

Go tidak memiliki pewarisan kelas. Penyematan adalah komposisi:

Penyematan membuat anggota dan metode tersedia, tetapi tipe luar bukan subtipe
Anda tidak dapat meneruskan Dog saat Animal diharapkan
Gunakan antarmuka untuk polimorfisme dan penyematan untuk penggunaan ulang kode

Menimpa Metode yang Diteruskan

Struktur luar dapat menyembunyikan metode yang disematkan dengan menentukan metodenya sendiri:

package main
import "fmt"

type Base struct{}
func (Base) Hello() string { return "Base hello" }

type Child struct{ Base }
func (Child) Hello() string { return "Child hello" } // shadows Base.Hello

func main() {
    c := Child{}
    fmt.Println(c.Hello())      // Child hello
    fmt.Println(c.Base.Hello()) // Base hello (explicit)
}

Struktur Anonim untuk Konfigurasi

Gunakan struktur anonim untuk mengelompokkan konfigurasi terkait tanpa menentukan tipe bernama:

package main
import "fmt"

func main() {
    cfg := struct {
        Host string
        Port int
        TLS  bool
    }{
        Host: "api.example.com",
        Port: 443,
        TLS:  true,
    }
    fmt.Println(cfg)
}

Menyematkan Antarmuka

Menyematkan antarmuka dalam struktur berguna untuk pembuatan tiruan dan implementasi bawaan:

package main
import "fmt"

type Reader interface{ Read() string }

type Mock struct{ Reader }  // embed interface

func main() {
    m := Mock{}
    fmt.Printf("%T\n", m.Reader) // <nil> — not set
    // Assign a real impl at test time:
    _ = m
}

Jebakan Komposisi Struktur

Perhatikan hal-hal berikut:

Pemilih ambigu saat dua tipe yang disematkan memiliki nama anggota atau metode yang sama
Penunjuk tersemat bernilai nil yang menyebabkan kepanikan saat Anda memanggil metode padanya
Jangan lupa bahwa penyematan bukan pewarisan—Anda tidak dapat menggantikan tipe tersemat dengan tipe luar

Membandingkan Struktur Anonim

Dua struktur anonim dengan nama dan tipe anggota yang sama dapat saling ditetapkan jika penandanya juga cocok:

package main
import "fmt"

func main() {
    a := struct{ X, Y int }{1, 2}
    b := struct{ X, Y int }{1, 2}
    fmt.Println(a == b) // true
}

Pemeriksaan Singkat

Apa hasil penyematan tipe dalam struktur?

Ringkasan: Komposisi

Hal-hal penting:

Struktur anonim cocok untuk pengujian berbasis tabel dan data berumur singkat
Penyematan membuat anggota dan metode tersedia—ini komposisi, bukan pewarisan
Tipe luar dapat menyembunyikan metode yang disematkan
Selesaikan pemilih ambigu secara eksplisit
Gunakan antarmuka untuk polimorfisme

Latihan

Buat struktur TimestampedRecord yang menyematkan Timestamp struct{ CreatedAt, UpdatedAt string } dan Data struct{ Key, Value string }. Buat instansnya dan cetak semua anggota yang tersedia melalui penyematan.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Struct Anonim dan Komposisi” gratis?

Ya — teks lengkap “Struct Anonim dan Komposisi” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Go Academy, upgrade ke CoddyKit PRO. Kursus Go Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Struct Anonim dan Komposisi”?

Embedding dan penggunaan ulang kode berbasis struct Kamu berlatih Go Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Go Academy?

Tidak diperlukan pengalaman sebelumnya. Go Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Struct Anonim dan Komposisi” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Go Academy ini?

Ya. Setiap pelajaran Go Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Go Academy