Go Academy · Lekcja

Struktury anonimowe i kompozycja

Osadzanie i ponowne wykorzystanie kodu opartego na strukturach

Struktury anonimowe i kompozycja to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Go Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Go Academy zawiera 4 lekcji w sumie.

Anonimowe struct

Anonimowy struct nie ma nazwanej definicji typu. Jest definiowany bezpośrednio w miejscu użycia i przydaje się w przypadku krótkotrwałych danych, testów tabelarycznych oraz jednorazowych grupowań:

package main
import "fmt"

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

Anonimowe struct w testach tabelarycznych

Popularny idiom języka Go polega na użyciu slice anonimowych struct w testach tabelarycznych:

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

Osadzanie struct

Osadzenie typu w struct udostępnia jego pola i metody w zewnętrznym struct:

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
}

Wiele osadzonych typów

Struct może osadzać wiele typów. Konflikty (ta sama nazwa pola lub metody) należy rozwiązywać jawnie:

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
}

Osadzanie a dziedziczenie

Go nie ma dziedziczenia klas. Osadzanie jest formą kompozycji:

Osadzanie udostępnia pola i metody, ale typ zewnętrzny nie jest podtypem
Nie można przekazać Dog tam, gdzie oczekiwany jest Animal
Interfejsów należy używać do polimorfizmu, a osadzania do ponownego wykorzystania kodu

Przesłanianie udostępnionych metod

Zewnętrzny struct może przesłonić osadzoną metodę, definiując własną:

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

Anonimowy struct do konfiguracji

Należy użyć anonimowego struct do pogrupowania powiązanych ustawień bez definiowania nazwanego typu:

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

Osadzanie interfejsu

Osadzanie interfejsu w struct przydaje się przy tworzeniu atrap oraz implementacji domyślnych:

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
}

Pułapki kompozycji struct

Należy uważać na:

Jednoznaczność selektorów, gdy dwa osadzone typy mają tę samą nazwę pola lub metody
Nilowy osadzony wskaźnik, który powoduje panic przy wywołaniu jego metod
Zapominanie, że osadzanie nie jest dziedziczeniem — nie można zastąpić typu osadzonego typem zewnętrznym

Porównywanie anonimowych struct

Dwa anonimowe struct o takich samych nazwach i typach pól można wzajemnie przypisywać, jeśli ich tagi również są takie same:

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
}

Szybkie sprawdzenie

Co zapewnia osadzenie typu w struct?

Podsumowanie: kompozycja

Najważniejsze informacje:

Anonimowe struct świetnie nadają się do testów tabelarycznych i krótkotrwałych danych
Osadzanie udostępnia pola i metody — jest kompozycją, a nie dziedziczeniem
Typy zewnętrzne mogą przesłaniać osadzone metody
Niejednoznaczne selektory należy rozwiązywać jawnie
Interfejsów należy używać do polimorfizmu

Polecenie do przećwiczenia

Należy utworzyć struct TimestampedRecord, który osadza Timestamp struct{ CreatedAt, UpdatedAt string } oraz Data struct{ Key, Value string }. Należy utworzyć jego instancję i wyświetlić wszystkie udostępnione pola.

Często zadawane pytania

Czy lekcja „Struktury anonimowe i kompozycja” jest bezpłatna?

Tak — pełny tekst „Struktury anonimowe i kompozycja” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Go Academy, przejdź na CoddyKit PRO. Kurs Go Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Struktury anonimowe i kompozycja”?

Osadzanie i ponowne wykorzystanie kodu opartego na strukturach Ćwiczysz Go Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Go Academy?

Nie wymagamy żadnego doświadczenia. Go Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Struktury anonimowe i kompozycja”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Go Academy?

Tak. Każda lekcja Go Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Go Academy