✍️ 필사 모드: Go 프로그래밍 완전 가이드 — 고루틴, 채널, 인터페이스, 실전 패턴

package main

import "fmt"

func main() {
    // 명시적 선언
    var name string = "Gopher"
    var age int = 10

    // 짧은 선언 (타입 추론)
    language := "Go"
    version := 1.22

    // 상수
    const pi = 3.14159

    fmt.Printf("%s는 %d살이고 %s %.2f를 씁니다\n",
        name, age, language, version)
    fmt.Println("원주율:", pi)
}

// 기본 함수
func add(a, b int) int {
    return a + b
}

// 다중 반환값
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("0으로 나눌 수 없습니다")
    }
    return a / b, nil
}

// 명명된 반환값
func swap(a, b string) (first, second string) {
    first = b
    second = a
    return // naked return
}

// 가변 인자
func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}

type User struct {
    Name  string
    Email string
    Age   int
}

// 메서드 (값 리시버)
func (u User) String() string {
    return fmt.Sprintf("%s (%s)", u.Name, u.Email)
}

// 메서드 (포인터 리시버 - 값 수정 가능)
func (u *User) SetEmail(email string) {
    u.Email = email
}

func main() {
    user := User{Name: "김영주", Email: "yj@example.com", Age: 30}
    user.SetEmail("new@example.com")
    fmt.Println(user) // 김영주 (new@example.com)
}

func main() {
    x := 42
    p := &x    // x의 주소
    fmt.Println(*p) // 42 (역참조)
    *p = 100
    fmt.Println(x) // 100
}

// Go에는 포인터 산술이 없습니다 - 안전합니다
// C와 달리 댕글링 포인터 걱정이 적습니다

func main() {
    // 슬라이스
    nums := []int{1, 2, 3, 4, 5}
    nums = append(nums, 6, 7)
    sub := nums[1:4] // [2, 3, 4]

    // make로 생성
    buffer := make([]byte, 0, 1024) // len=0, cap=1024

    // 맵
    scores := map[string]int{
        "Alice": 95,
        "Bob":   87,
    }
    scores["Charlie"] = 92

    // 키 존재 확인
    val, ok := scores["Dave"]
    if !ok {
        fmt.Println("Dave의 점수가 없습니다")
    }

    // 맵 순회
    for name, score := range scores {
        fmt.Printf("%s: %d\n", name, score)
    }
}

func worker(id int) {
    fmt.Printf("Worker %d 시작\n", id)
    time.Sleep(time.Second)
    fmt.Printf("Worker %d 완료\n", id)
}

func main() {
    for i := 1; i <= 5; i++ {
        go worker(i) // 고루틴 실행
    }

    // 메인 고루틴이 끝나면 프로그램 종료
    time.Sleep(2 * time.Second)
}

func producer(ch chan<- int) {
    for i := 0; i < 5; i++ {
        ch <- i // 채널에 값 전송
        fmt.Printf("전송: %d\n", i)
    }
    close(ch) // 채널 닫기
}

func consumer(ch <-chan int) {
    for val := range ch { // 채널이 닫힐 때까지 수신
        fmt.Printf("수신: %d\n", val)
    }
}

func main() {
    ch := make(chan int, 3) // 버퍼 크기 3

    go producer(ch)
    consumer(ch) // 메인 고루틴에서 소비
}

func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)

    go func() {
        time.Sleep(1 * time.Second)
        ch1 <- "one"
    }()

    go func() {
        time.Sleep(2 * time.Second)
        ch2 <- "two"
    }()

    for i := 0; i < 2; i++ {
        select {
        case msg := <-ch1:
            fmt.Println("ch1:", msg)
        case msg := <-ch2:
            fmt.Println("ch2:", msg)
        case <-time.After(3 * time.Second):
            fmt.Println("타임아웃!")
        }
    }
}

func main() {
    var wg sync.WaitGroup

    urls := []string{
        "https://example.com",
        "https://golang.org",
        "https://github.com",
    }

    for _, url := range urls {
        wg.Add(1)
        go func(u string) {
            defer wg.Done()
            resp, err := http.Get(u)
            if err != nil {
                fmt.Printf("에러: %s - %v\n", u, err)
                return
            }
            defer resp.Body.Close()
            fmt.Printf("%s -> %s\n", u, resp.Status)
        }(url)
    }

    wg.Wait() // 모든 고루틴 완료 대기
    fmt.Println("모든 요청 완료")
}

// 나쁜 예: 데드락 발생
func bad() {
    ch := make(chan int) // 버퍼 없는 채널
    ch <- 1             // 수신자가 없어서 영원히 블록
    fmt.Println(<-ch)
}

// 좋은 예 1: 고루틴으로 전송
func good1() {
    ch := make(chan int)
    go func() { ch <- 1 }()
    fmt.Println(<-ch)
}

// 좋은 예 2: 버퍼 채널 사용
func good2() {
    ch := make(chan int, 1)
    ch <- 1
    fmt.Println(<-ch)
}

func workerPool(jobs <-chan int, results chan<- int, id int) {
    for j := range jobs {
        fmt.Printf("Worker %d 처리 중: job %d\n", id, j)
        time.Sleep(time.Millisecond * 500)
        results <- j * 2
    }
}

func main() {
    const numJobs = 10
    const numWorkers = 3

    jobs := make(chan int, numJobs)
    results := make(chan int, numJobs)

    // 워커 시작
    for w := 1; w <= numWorkers; w++ {
        go workerPool(jobs, results, w)
    }

    // 작업 전송
    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs)

    // 결과 수집
    for r := 1; r <= numJobs; r++ {
        result := <-results
        fmt.Printf("결과: %d\n", result)
    }
}

type Shape interface {
    Area() float64
    Perimeter() float64
}

type Circle struct {
    Radius float64
}

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

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

type Rectangle struct {
    Width, Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

// Shape 인터페이스를 매개변수로 받는 함수
func printInfo(s Shape) {
    fmt.Printf("면적: %.2f, 둘레: %.2f\n", s.Area(), s.Perimeter())
}

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

// io.Writer 인터페이스
// type Writer interface {
//     Write(p []byte) (n int, err error)
// }

func countBytes(r io.Reader) (int, error) {
    buf := make([]byte, 1024)
    total := 0
    for {
        n, err := r.Read(buf)
        total += n
        if err == io.EOF {
            return total, nil
        }
        if err != nil {
            return total, err
        }
    }
}

func main() {
    // 문자열에서 읽기
    r := strings.NewReader("Hello, Go!")
    n, _ := countBytes(r)
    fmt.Printf("%d 바이트\n", n) // 10 바이트

    // 파일에서 읽기
    f, _ := os.Open("data.txt")
    defer f.Close()
    n, _ = countBytes(f)
    fmt.Printf("%d 바이트\n", n)
}

func describe(i interface{}) {
    // 타입 단언
    if s, ok := i.(string); ok {
        fmt.Println("문자열:", s)
        return
    }

    // 타입 스위치
    switch v := i.(type) {
    case int:
        fmt.Println("정수:", v)
    case float64:
        fmt.Println("실수:", v)
    case bool:
        fmt.Println("불린:", v)
    default:
        fmt.Printf("알 수 없는 타입: %T\n", v)
    }
}

func main() {
    describe(42)
    describe("hello")
    describe(3.14)
    describe(true)
}

type Reader interface {
    Read(p []byte) (n int, err error)
}

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

type Closer interface {
    Close() error
}

// 인터페이스 조합 (embedding)
type ReadWriter interface {
    Reader
    Writer
}

type ReadWriteCloser interface {
    Reader
    Writer
    Closer
}

import (
    "errors"
    "fmt"
)

var ErrNotFound = errors.New("not found")

func findUser(id int) (*User, error) {
    if id <= 0 {
        return nil, fmt.Errorf("잘못된 사용자 ID: %d", id)
    }
    // ... DB 조회
    return nil, ErrNotFound
}

type ValidationError struct {
    Field   string
    Message string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("유효성 검사 실패 - %s: %s", e.Field, e.Message)
}

func validateAge(age int) error {
    if age < 0 || age > 150 {
        return &ValidationError{
            Field:   "age",
            Message: fmt.Sprintf("나이는 0-150 범위여야 합니다 (입력값: %d)", age),
        }
    }
    return nil
}

func processUser(age int) error {
    if err := validateAge(age); err != nil {
        return fmt.Errorf("사용자 처리 실패: %w", err) // 에러 래핑
    }
    return nil
}

func main() {
    err := processUser(-5)

    // errors.Is: 에러 체인에서 특정 에러 확인
    if errors.Is(err, ErrNotFound) {
        fmt.Println("사용자를 찾을 수 없습니다")
    }

    // errors.As: 에러 체인에서 특정 타입으로 변환
    var valErr *ValidationError
    if errors.As(err, &valErr) {
        fmt.Printf("필드: %s, 메시지: %s\n", valErr.Field, valErr.Message)
    }
}

type AppError struct {
    Code    int
    Message string
    Err     error
}

func (e *AppError) Error() string {
    if e.Err != nil {
        return fmt.Sprintf("[%d] %s: %v", e.Code, e.Message, e.Err)
    }
    return fmt.Sprintf("[%d] %s", e.Code, e.Message)
}

func (e *AppError) Unwrap() error {
    return e.Err
}

// 에러 생성 헬퍼
func NewAppError(code int, msg string, err error) *AppError {
    return &AppError{Code: code, Message: msg, Err: err}
}

func Min[T constraints.Ordered](a, b T) T {
    if a < b {
        return a
    }
    return b
}

func main() {
    fmt.Println(Min(3, 5))       // int
    fmt.Println(Min(3.14, 2.71)) // float64
    fmt.Println(Min("a", "b"))   // string
}

import "golang.org/x/exp/constraints"

// 커스텀 제약 조건
type Number interface {
    constraints.Integer | constraints.Float
}

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

// 구조체에 제네릭 적용
type Stack[T any] struct {
    items []T
}

func (s *Stack[T]) Push(item T) {
    s.items = append(s.items, item)
}

func (s *Stack[T]) Pop() (T, bool) {
    if len(s.items) == 0 {
        var zero T
        return zero, false
    }
    item := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return item, true
}

func (s *Stack[T]) Len() int {
    return len(s.items)
}

func Keys[K comparable, V any](m map[K]V) []K {
    keys := make([]K, 0, len(m))
    for k := range m {
        keys = append(keys, k)
    }
    return keys
}

func Values[K comparable, V any](m map[K]V) []V {
    vals := make([]V, 0, len(m))
    for _, v := range m {
        vals = append(vals, v)
    }
    return vals
}

func Filter[T any](slice []T, predicate func(T) bool) []T {
    var result []T
    for _, item := range slice {
        if predicate(item) {
            result = append(result, item)
        }
    }
    return result
}

func Map[T any, U any](slice []T, transform func(T) U) []U {
    result := make([]U, len(slice))
    for i, item := range slice {
        result[i] = transform(item)
    }
    return result
}

// math.go
package math

func Add(a, b int) int {
    return a + b
}

func Fibonacci(n int) int {
    if n <= 1 {
        return n
    }
    return Fibonacci(n-1) + Fibonacci(n-2)
}

// math_test.go
package math

import "testing"

func TestAdd(t *testing.T) {
    result := Add(2, 3)
    if result != 5 {
        t.Errorf("Add(2, 3) = %d; want 5", result)
    }
}

func TestFibonacci(t *testing.T) {
    tests := []struct {
        name     string
        input    int
        expected int
    }{
        {"zero", 0, 0},
        {"one", 1, 1},
        {"two", 2, 1},
        {"five", 5, 5},
        {"ten", 10, 55},
    }

    for _, tc := range tests {
        t.Run(tc.name, func(t *testing.T) {
            result := Fibonacci(tc.input)
            if result != tc.expected {
                t.Errorf("Fibonacci(%d) = %d; want %d",
                    tc.input, result, tc.expected)
            }
        })
    }
}

func BenchmarkFibonacci(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Fibonacci(20)
    }
}

// 실행: go test -bench=. -benchmem
// BenchmarkFibonacci-8  28735  41523 ns/op  0 B/op  0 allocs/op

func TestHealthHandler(t *testing.T) {
    req := httptest.NewRequest("GET", "/health", nil)
    w := httptest.NewRecorder()

    healthHandler(w, req)

    resp := w.Result()
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        t.Errorf("상태 코드 = %d; want %d",
            resp.StatusCode, http.StatusOK)
    }

    body, _ := io.ReadAll(resp.Body)
    if string(body) != `{"status":"ok"}` {
        t.Errorf("응답 = %s; want {\"status\":\"ok\"}", body)
    }
}

# 새 프로젝트 시작
mkdir myproject && cd myproject
go mod init github.com/username/myproject

# 의존성 추가
go get github.com/gin-gonic/gin@latest

# 사용하지 않는 의존성 정리
go mod tidy

# 의존성 다운로드
go mod download

myproject/
  cmd/
    server/
      main.go          # 엔트리포인트
  internal/
    handler/
      user.go          # HTTP 핸들러
      user_test.go
    service/
      user.go          # 비즈니스 로직
    repository/
      user.go          # 데이터 접근
  pkg/
    validator/
      validator.go     # 외부 공개 유틸리티
  go.mod
  go.sum

// internal/config/config.go
package config

type Config struct {
    Port     int
    DBHost   string
    LogLevel string
}

func Load() (*Config, error) {
    // 환경 변수에서 설정 로드
    return &Config{
        Port:     8080,
        DBHost:   "localhost:5432",
        LogLevel: "info",
    }, nil
}

package main

import (
    "encoding/json"
    "log"
    "net/http"
    "time"
)

type Response struct {
    Message   string `json:"message"`
    Timestamp string `json:"timestamp"`
}

func healthHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(Response{
        Message:   "ok",
        Timestamp: time.Now().Format(time.RFC3339),
    })
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("GET /health", healthHandler)
    mux.HandleFunc("GET /api/users", getUsersHandler)

    server := &http.Server{
        Addr:         ":8080",
        Handler:      mux,
        ReadTimeout:  10 * time.Second,
        WriteTimeout: 10 * time.Second,
        IdleTimeout:  60 * time.Second,
    }

    log.Printf("서버 시작: %s", server.Addr)
    log.Fatal(server.ListenAndServe())
}

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        log.Printf("[%s] %s 시작", r.Method, r.URL.Path)

        next.ServeHTTP(w, r)

        log.Printf("[%s] %s 완료 (%v)",
            r.Method, r.URL.Path, time.Since(start))
    })
}

func authMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        token := r.Header.Get("Authorization")
        if token == "" {
            http.Error(w, "인증 필요", http.StatusUnauthorized)
            return
        }
        // 토큰 검증 로직...
        next.ServeHTTP(w, r)
    })
}

// 미들웨어 체이닝
func chain(h http.Handler, middlewares ...func(http.Handler) http.Handler) http.Handler {
    for i := len(middlewares) - 1; i >= 0; i-- {
        h = middlewares[i](h)
    }
    return h
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("GET /health", healthHandler)

    handler := chain(mux, loggingMiddleware, authMiddleware)

    log.Fatal(http.ListenAndServe(":8080", handler))
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("GET /health", healthHandler)

    server := &http.Server{
        Addr:    ":8080",
        Handler: mux,
    }

    // 서버를 고루틴에서 시작
    go func() {
        log.Println("서버 시작: :8080")
        if err := server.ListenAndServe(); err != http.ErrServerClosed {
            log.Fatalf("서버 에러: %v", err)
        }
    }()

    // 종료 시그널 대기
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit
    log.Println("서버 종료 시작...")

    // 30초 타임아웃으로 graceful shutdown
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    if err := server.Shutdown(ctx); err != nil {
        log.Fatalf("서버 강제 종료: %v", err)
    }

    log.Println("서버 종료 완료")
}

type Config struct {
    Server   ServerConfig
    Database DatabaseConfig
}

type ServerConfig struct {
    Port         int           `json:"port"`
    ReadTimeout  time.Duration `json:"read_timeout"`
    WriteTimeout time.Duration `json:"write_timeout"`
}

type DatabaseConfig struct {
    Host     string `json:"host"`
    Port     int    `json:"port"`
    User     string `json:"user"`
    Password string `json:"password"`
    DBName   string `json:"dbname"`
}

func (d DatabaseConfig) DSN() string {
    return fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable",
        d.Host, d.Port, d.User, d.Password, d.DBName)
}

func LoadConfig(path string) (*Config, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, fmt.Errorf("설정 파일 읽기 실패: %w", err)
    }

    var cfg Config
    if err := json.Unmarshal(data, &cfg); err != nil {
        return nil, fmt.Errorf("설정 파싱 실패: %w", err)
    }

    return &cfg, nil
}

// cobra를 이용한 CLI 예제
package main

import (
    "fmt"
    "os"

    "github.com/spf13/cobra"
)

var rootCmd = &cobra.Command{
    Use:   "mytool",
    Short: "나의 CLI 도구",
}

var greetCmd = &cobra.Command{
    Use:   "greet [name]",
    Short: "인사하기",
    Args:  cobra.ExactArgs(1),
    Run: func(cmd *cobra.Command, args []string) {
        fmt.Printf("안녕하세요, %s!\n", args[0])
    },
}

func main() {
    rootCmd.AddCommand(greetCmd)
    if err := rootCmd.Execute(); err != nil {
        os.Exit(1)
    }
}

# 멀티 스테이지 빌드
FROM golang:1.22-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -o /server ./cmd/server

FROM scratch
COPY --from=builder /server /server
EXPOSE 8080
ENTRYPOINT ["/server"]