Go 구조체/인터페이스 완전 정리

Go code

package main

import (
	"fmt"
	"math"
)

// 구조체 정의
type Point struct {
	X, Y float64
}

// 값 수신자 메서드 — 복사본에서 실행
func (p Point) Distance() float64 {
	return math.Sqrt(p.X*p.X + p.Y*p.Y)
}

// 포인터 수신자 메서드 — 원본 수정 가능
func (p *Point) Scale(factor float64) {
	p.X *= factor
	p.Y *= factor
}

func (p Point) String() string {
	return fmt.Sprintf("(%.1f, %.1f)", p.X, p.Y)
}

// 임베딩 — 상속 대신
type Circle struct {
	Point        // 임베딩 (익명 필드)
	Radius float64
}

func (c Circle) Area() float64 {
	return math.Pi * c.Radius * c.Radius
}

// 구조체 태그 (JSON, DB 매핑)
type User struct {
	ID    int    `json:"id"`
	Name  string `json:"name"`
	Email string `json:"email,omitempty"`
}

func main() {
	p := Point{X: 3, Y: 4}
	fmt.Println(p.Distance())  // 5
	p.Scale(2)
	fmt.Println(p)             // (6.0, 8.0)

	// 임베딩으로 Point 메서드 승격
	c := Circle{Point: Point{1, 2}, Radius: 5}
	fmt.Println(c.Distance()) // 임베딩된 Point의 메서드
	fmt.Printf("넓이: %.2f
", c.Area())

	// 구조체 리터럴
	u1 := User{ID: 1, Name: "Alice"}
	u2 := User{1, "Bob", "bob@test.com"}
	_ = u1; _ = u2

	// 익명 구조체
	config := struct {
		Host string
		Port int
	}{"localhost", 8080}
	fmt.Println(config.Host, config.Port)
}

Go code

package main

import (
	"fmt"
	"math"
)

// 인터페이스 정의
type Shape interface {
	Area() float64
	Perimeter() float64
}

// Stringer 인터페이스 (fmt.Stringer)
type Stringer interface {
	String() string
}

// 구현체 — 명시적 선언 없음
type Rectangle struct{ W, H float64 }
func (r Rectangle) Area() float64      { return r.W * r.H }
func (r Rectangle) Perimeter() float64 { return 2*(r.W+r.H) }
func (r Rectangle) String() string {
	return fmt.Sprintf("Rect(%.1f×%.1f)", r.W, r.H)
}

type Circle struct{ R float64 }
func (c Circle) Area() float64      { return math.Pi * c.R * c.R }
func (c Circle) Perimeter() float64 { return 2 * math.Pi * c.R }

// 인터페이스를 파라미터로
func printShape(s Shape) {
	fmt.Printf("넓이: %.2f, 둘레: %.2f
", s.Area(), s.Perimeter())
}

// 인터페이스 슬라이스
func totalArea(shapes []Shape) float64 {
	var total float64
	for _, s := range shapes { total += s.Area() }
	return total
}

// 빈 인터페이스 — 모든 타입 허용
func describe(i interface{}) {
	fmt.Printf("타입: %T, 값: %v
", i, i)
}

// 타입 단언
func main() {
	shapes := []Shape{
		Rectangle{3, 4},
		Circle{5},
	}
	for _, s := range shapes { printShape(s) }
	fmt.Printf("총 넓이: %.2f
", totalArea(shapes))

	describe(42)
	describe("hello")
	describe(Rectangle{1, 2})

	// 타입 단언
	var s Shape = Rectangle{3, 4}
	if r, ok := s.(Rectangle); ok {
		fmt.Println("Rectangle:", r.W, r.H)
	}
}

Go code

package main

import (
	"fmt"
	"golang.org/x/exp/constraints"
)

// 타입 파라미터 — [T constraint]
func Map[T, U any](s []T, fn func(T) U) []U {
	result := make([]U, len(s))
	for i, v := range s { result[i] = fn(v) }
	return result
}

func Filter[T any](s []T, fn func(T) bool) []T {
	var result []T
	for _, v := range s {
		if fn(v) { result = append(result, v) }
	}
	return result
}

// constraints.Ordered — 정렬 가능한 타입 제약
func Min[T constraints.Ordered](a, b T) T {
	if a < b { return a }
	return b
}

// 제네릭 구조체
type Stack[T any] struct {
	data []T
}

func (s *Stack[T]) Push(v T)     { s.data = append(s.data, v) }
func (s *Stack[T]) Pop() (T, bool) {
	if len(s.data) == 0 {
		var zero T
		return zero, false
	}
	n := len(s.data) - 1
	v := s.data[n]
	s.data = s.data[:n]
	return v, true
}
func (s *Stack[T]) Len() int { return len(s.data) }

// 커스텀 타입 제약
type Number interface {
	~int | ~int32 | ~int64 | ~float32 | ~float64
}

func Sum[T Number](nums []T) T {
	var total T
	for _, n := range nums { total += n }
	return total
}

func main() {
	nums := []int{1, 2, 3, 4, 5}
	doubled := Map(nums, func(n int) int { return n * 2 })
	fmt.Println(doubled) // [2 4 6 8 10]

	strs := Map(nums, func(n int) string {
		return fmt.Sprintf("item%d", n)
	})
	fmt.Println(strs)

	evens := Filter(nums, func(n int) bool { return n%2 == 0 })
	fmt.Println(evens) // [2 4]

	fmt.Println(Min(3, 5))       // 3
	fmt.Println(Min("a", "b"))   // a

	var s Stack[string]
	s.Push("hello"); s.Push("world")
	if v, ok := s.Pop(); ok { fmt.Println(v) } // world

	fmt.Println(Sum([]float64{1.1, 2.2, 3.3}))
}

Go code

<span class="cm">// maps 패키지 (Go 1.21+) 예제
// data/prompts.js의 생성 프롬프트로 상세 코드 생성 가능</span>
fun main() { println("maps 패키지 (Go 1.21+)") }

Go code

package main

import "fmt"

// 1. 구조체 임베딩 기초
type Logger struct {
	Prefix string
}

func (l Logger) Log(msg string) {
	fmt.Printf("[%s] %s\n", l.Prefix, msg)
}

func (l Logger) Error(msg string) {
	fmt.Printf("[%s] ERROR: %s\n", l.Prefix, msg)
}

type Server struct {
	Logger     // 임베딩: Logger의 메서드가 승격됨
	Host string
	Port int
}

// 2. 메서드 오버라이드 (shadowing)
func (s Server) Log(msg string) {
	// 원래 Logger.Log도 호출 가능
	s.Logger.Log(fmt.Sprintf("%s:%d - %s", s.Host, s.Port, msg))
}

// 3. 인터페이스 임베딩
type Reader interface {
	Read(p []byte) (n int, err error)
}

type Writer interface {
	Write(p []byte) (n int, err error)
}

// Reader + Writer 조합
type ReadWriter interface {
	Reader
	Writer
}

// 4. 다중 임베딩
type Metrics struct {
	RequestCount int
}

func (m *Metrics) IncrementRequests() {
	m.RequestCount++
}

func (m Metrics) Report() string {
	return fmt.Sprintf("요청 수: %d", m.RequestCount)
}

type APIServer struct {
	Server     // Logger 포함
	*Metrics   // 포인터 임베딩도 가능
	Version string
}

func main() {
	// 구조체 임베딩 사용
	srv := Server{
		Logger: Logger{Prefix: "WEB"},
		Host:   "localhost",
		Port:   8080,
	}
	srv.Log("서버 시작")          // Server.Log 호출 (오버라이드됨)
	srv.Error("연결 실패")        // Logger.Error 직접 승격

	// 다중 임베딩
	api := APIServer{
		Server:  srv,
		Metrics: &Metrics{},
		Version: "v2",
	}
	api.Log("API 요청 처리")      // Server.Log → Logger.Log
	api.IncrementRequests()       // Metrics.IncrementRequests
	api.IncrementRequests()
	fmt.Println(api.Report())     // "요청 수: 2"
	fmt.Printf("서버: %s:%d (%s)\n", api.Host, api.Port, api.Version)
}

Go code

package main

import "fmt"

type Animal struct {
	Name string
}

func (a Animal) Speak() string {
	return a.Name + "이(가) 소리를 냅니다"
}

type Dog struct {
	Animal     // 임베딩
	Breed string
}

// 메서드 오버라이드
func (d Dog) Speak() string {
	return d.Name + ": 멍멍!"
}

type Cat struct {
	Animal
}

func (c Cat) Speak() string {
	return c.Name + ": 야옹~"
}

type Speaker interface {
	Speak() string
}

func main() {
	pets := []Speaker{
		Dog{Animal: Animal{Name: "바둑이"}, Breed: "진돗개"},
		Cat{Animal: Animal{Name: "나비"}},
	}
	for _, p := range pets {
		fmt.Println(p.Speak())
	}
}

Go code

package main

import "fmt"

// 원칙 1: 작은 인터페이스
type Saver interface {
	Save(data []byte) error
}

// 원칙 2: 소비자 측에서 정의
// 패키지 A가 인터페이스를 정의, 패키지 B가 구현
type Notifier interface {
	Notify(msg string) error
}

// 구현체들 — 인터페이스를 몰라도 됨
type FileSaver struct{ Path string }
func (f FileSaver) Save(data []byte) error {
	fmt.Printf("파일 저장: %s (%d bytes)\n", f.Path, len(data))
	return nil
}

type SlackNotifier struct{ Webhook string }
func (s SlackNotifier) Notify(msg string) error {
	fmt.Printf("Slack 알림: %s\n", msg)
	return nil
}

// 인터페이스를 받아 사용
func backup(s Saver, n Notifier) {
	s.Save([]byte("backup data"))
	n.Notify("백업 완료")
}

func main() {
	backup(
		FileSaver{Path: "/backup"},
		SlackNotifier{Webhook: "https://hooks.slack.com/..."},
	)
}

Go code

package main

import "fmt"

// 인터페이스 정의
type UserRepo interface {
	FindByID(id int) (string, error)
}

type Mailer interface {
	Send(to, subject string) error
}

// 서비스: 의존성 주입
type UserService struct {
	repo   UserRepo
	mailer Mailer
}

func NewUserService(r UserRepo, m Mailer) *UserService {
	return &UserService{repo: r, mailer: m}
}

func (s *UserService) Greet(id int) error {
	name, err := s.repo.FindByID(id)
	if err != nil { return err }
	return s.mailer.Send(name, "환영합니다!")
}

// 구현체
type MemoryRepo struct{ users map[int]string }
func (r *MemoryRepo) FindByID(id int) (string, error) {
	if u, ok := r.users[id]; ok { return u, nil }
	return "", fmt.Errorf("사용자 없음: %d", id)
}

type ConsoleMailer struct{}
func (m *ConsoleMailer) Send(to, subj string) error {
	fmt.Printf("메일 → %s: %s\n", to, subj)
	return nil
}

func main() {
	repo := &MemoryRepo{users: map[int]string{1: "Gopher"}}
	svc := NewUserService(repo, &ConsoleMailer{})
	svc.Greet(1)
}

Go code

package main

import "fmt"

type Database interface {
	Connect() string
	Query(sql string) string
}

type postgres struct{ dsn string }
func (p *postgres) Connect() string { return "PostgreSQL 연결: " + p.dsn }
func (p *postgres) Query(sql string) string { return "PG: " + sql }

type sqlite struct{ path string }
func (s *sqlite) Connect() string { return "SQLite 열기: " + s.path }
func (s *sqlite) Query(sql string) string { return "SQLite: " + sql }

// 팩토리 함수
func NewDatabase(driver, source string) (Database, error) {
	switch driver {
	case "postgres":
		return &postgres{dsn: source}, nil
	case "sqlite":
		return &sqlite{path: source}, nil
	default:
		return nil, fmt.Errorf("미지원 드라이버: %s", driver)
	}
}

func main() {
	db, err := NewDatabase("postgres", "host=localhost")
	if err != nil { panic(err) }
	fmt.Println(db.Connect())
	fmt.Println(db.Query("SELECT 1"))
}

Go code

package main

import "fmt"

type Query struct {
	table  string
	wheres []string
	order  string
	limit  int
}

type QueryBuilder struct {
	q Query
}

func Select(table string) *QueryBuilder {
	return &QueryBuilder{q: Query{table: table}}
}

func (b *QueryBuilder) Where(cond string) *QueryBuilder {
	b.q.wheres = append(b.q.wheres, cond)
	return b // 체이닝
}

func (b *QueryBuilder) OrderBy(col string) *QueryBuilder {
	b.q.order = col
	return b
}

func (b *QueryBuilder) Limit(n int) *QueryBuilder {
	b.q.limit = n
	return b
}

func (b *QueryBuilder) Build() string {
	sql := "SELECT * FROM " + b.q.table
	for i, w := range b.q.wheres {
		if i == 0 { sql += " WHERE " } else { sql += " AND " }
		sql += w
	}
	if b.q.order != "" { sql += " ORDER BY " + b.q.order }
	if b.q.limit > 0 { sql += fmt.Sprintf(" LIMIT %d", b.q.limit) }
	return sql
}

func main() {
	sql := Select("users").
		Where("age > 18").
		Where("active = true").
		OrderBy("name").
		Limit(10).
		Build()
	fmt.Println(sql)
}

Go code

package main

import "fmt"

type ClientConfig struct {
	BaseURL    string
	Timeout    int
	RetryCount int
	Verbose    bool
}

// 기본값을 제공하는 생성자
func DefaultConfig() ClientConfig {
	return ClientConfig{
		BaseURL:    "https://api.example.com",
		Timeout:    30,
		RetryCount: 3,
		Verbose:    false,
	}
}

type Client struct {
	config ClientConfig
}

func NewClient(cfg ClientConfig) *Client {
	// 누락된 값에 기본값 적용
	if cfg.BaseURL == "" {
		cfg.BaseURL = DefaultConfig().BaseURL
	}
	if cfg.Timeout <= 0 {
		cfg.Timeout = DefaultConfig().Timeout
	}
	return &Client{config: cfg}
}

func main() {
	// 기본값 + 일부 커스터마이징
	cfg := DefaultConfig()
	cfg.Timeout = 60
	cfg.Verbose = true

	c := NewClient(cfg)
	fmt.Printf("URL: %s, Timeout: %d\n", c.config.BaseURL, c.config.Timeout)
}

Go code

package main

import (
	"errors"
	"fmt"
)

type User struct {
	ID   int
	Name string
}

// 리포지토리 인터페이스
type UserRepository interface {
	FindByID(id int) (*User, error)
	Save(user *User) error
	FindAll() ([]*User, error)
}

// 인메모리 구현
type memoryUserRepo struct {
	users map[int]*User
	seq   int
}

func NewMemoryUserRepo() UserRepository {
	return &memoryUserRepo{users: make(map[int]*User)}
}

func (r *memoryUserRepo) FindByID(id int) (*User, error) {
	u, ok := r.users[id]
	if !ok { return nil, errors.New("사용자 없음") }
	return u, nil
}

func (r *memoryUserRepo) Save(u *User) error {
	if u.ID == 0 { r.seq++; u.ID = r.seq }
	r.users[u.ID] = u
	return nil
}

func (r *memoryUserRepo) FindAll() ([]*User, error) {
	all := make([]*User, 0, len(r.users))
	for _, u := range r.users { all = append(all, u) }
	return all, nil
}

func main() {
	repo := NewMemoryUserRepo()
	repo.Save(&User{Name: "Gopher"})
	repo.Save(&User{Name: "Rustacean"})
	users, _ := repo.FindAll()
	for _, u := range users { fmt.Printf("%+v\n", *u) }
}

Go code

package main

import (
	"errors"
	"fmt"
)

type Order struct {
	ID     int
	UserID int
	Total  float64
	Status string
}

type OrderRepo interface {
	Save(o *Order) error
	FindByID(id int) (*Order, error)
}

// 서비스: 비즈니스 로직 담당
type OrderService struct {
	repo OrderRepo
}

func NewOrderService(r OrderRepo) *OrderService {
	return &OrderService{repo: r}
}

func (s *OrderService) PlaceOrder(userID int, total float64) (*Order, error) {
	if total <= 0 {
		return nil, errors.New("주문 금액은 0보다 커야 합니다")
	}
	order := &Order{UserID: userID, Total: total, Status: "pending"}
	if err := s.repo.Save(order); err != nil {
		return nil, fmt.Errorf("주문 저장 실패: %w", err)
	}
	return order, nil
}

// 간단한 인메모리 구현
type memOrderRepo struct{ orders map[int]*Order; seq int }
func (r *memOrderRepo) Save(o *Order) error { r.seq++; o.ID = r.seq; r.orders[o.ID] = o; return nil }
func (r *memOrderRepo) FindByID(id int) (*Order, error) { o, ok := r.orders[id]; if !ok { return nil, errors.New("없음") }; return o, nil }

func main() {
	repo := &memOrderRepo{orders: make(map[int]*Order)}
	svc := NewOrderService(repo)
	order, _ := svc.PlaceOrder(1, 29900)
	fmt.Printf("주문 생성: %+v\n", *order)
}

Go code

package main

import (
	"errors"
	"fmt"
)

// 값 객체 (Value Object) — 불변, 동등성으로 비교
type Money struct {
	Amount   int64
	Currency string
}

func (m Money) Add(other Money) (Money, error) {
	if m.Currency != other.Currency {
		return Money{}, errors.New("통화 불일치")
	}
	return Money{Amount: m.Amount + other.Amount, Currency: m.Currency}, nil
}

// 엔티티 — ID로 식별
type Product struct {
	ID    string
	Name  string
	Price Money
}

// 애그리거트 루트
type Cart struct {
	ID    string
	Items []CartItem
}

type CartItem struct {
	Product Product
	Qty     int
}

func (c *Cart) AddItem(p Product, qty int) {
	c.Items = append(c.Items, CartItem{Product: p, Qty: qty})
}

func (c *Cart) Total() Money {
	total := Money{Currency: "KRW"}
	for _, item := range c.Items {
		m := Money{Amount: item.Product.Price.Amount * int64(item.Qty), Currency: "KRW"}
		total, _ = total.Add(m)
	}
	return total
}

func main() {
	p := Product{ID: "1", Name: "Go 책", Price: Money{35000, "KRW"}}
	cart := &Cart{ID: "cart-1"}
	cart.AddItem(p, 2)
	fmt.Printf("총액: %d %s\n", cart.Total().Amount, cart.Total().Currency)
}

Go code

package main

import "fmt"

// S — 단일 책임: 각 타입이 하나의 역할
type Validator struct{}
func (v Validator) Validate(email string) bool { return len(email) > 3 }

type Formatter struct{}
func (f Formatter) Format(name string) string { return "Mr./Ms. " + name }

// O — 개방/폐쇄: 인터페이스로 확장
type Notifier interface { Notify(msg string) }

type EmailNotifier struct{}
func (e EmailNotifier) Notify(msg string) { fmt.Println("이메일:", msg) }

type SMSNotifier struct{}
func (s SMSNotifier) Notify(msg string) { fmt.Println("SMS:", msg) }

// I — 인터페이스 분리: 작은 인터페이스
type Reader interface { Read() string }
type Writer interface { Write(s string) }

// D — 의존성 역전: 추상에 의존
type App struct {
	notifiers []Notifier
}

func (a *App) Alert(msg string) {
	for _, n := range a.notifiers {
		n.Notify(msg) // 인터페이스에 의존
	}
}

func main() {
	app := &App{notifiers: []Notifier{EmailNotifier{}, SMSNotifier{}}}
	app.Alert("서버 점검 안내")
}