[Go] Mordern Go 기본2(함수, 인터페이스, 메서드, 에러)

 

함수

✔ 여러개 반환값

func divmod(a, b int) (int, int) {
    return a / b, a % b
}

q, r := divmod(10, 3)  // q=3, r=1

✔  이름 있는 반환값

func sum(a, b int) (result int) {
    result = a + b
    return // 이름 있으면 return 시 변수 생략 가능
}

✔  함수도 일급객체

func operate(a, b int, f func(int, int) int) int {
    return f(a, b)
}

sum := func(x, y int) int { return x + y } // 람다
result := operate(3, 4, sum)  // 7

✔  람다(익명함수)

result := func(x int) int {
    return x * 2
}(5)  // 10

✔  panic & recover

func safeDivide(a, b int) {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("에러 발생:", r)
        }
    }()
    fmt.Println(a / b)  // b=0일 경우 panic
}

✔  Defer: 함수 종료시 실행됨

func writeLog(w io.Writer, message string) {
    fmt.Fprintf(w, "[Log] %s\\n", message)
}

func main() {
    f, _ := os.Create("app.log")
    defer f.Close()

    writeLog(f, "File log")        // 파일에 출력
    writeLog(os.Stdout, "Console") // 콘솔에 출력
}

✔  가변 인수 함수

func printArgs(args ...string) {
    fmt.Printf("타입: %T\\n", args) // []string
    for _, arg := range args {
        fmt.Println(arg)
    }
}

✔  슬라이스를 unpacking 형태로 가변 인수 전달

words := []string{"hello", "world"}
printArgs(words...) // 슬라이스 → 가변 인수로 전달 (words... 반드시 필요)

✔  고정 인수 + 가변 인수 조합 가능

func log(level string, msgs ...string) {
    for _, msg := range msgs {
        fmt.Printf("[%s] %s\\n", level, msg)
    }
}

log("INFO", "started", "processing") // [INFO] started \\n [INFO] processing

---

⚠️ 주의사항

항목	설명
인자가 0개일 수도 있음	len(nums)를 체크해야 안전
타입이 고정되어야 함	...interface{}를 쓰면 모든 타입을 받을 수 있음
성능 이슈	큰 배열이나 빈번한 호출에서는 슬라이스 생성 비용 고려

---

🔧 모든 타입 수용 예 (interface{})

func logAnything(args ...interface{}) {
    for _, a := range args {
        fmt.Printf("Value: %v, Type: %T\\n", a, a)
    }
}

logAnything(123, "hello", true, 3.14)

 

✅ 주요 특징

항목	설명
다중 반환	(T1, T2) 형태로 여러 값 반환 가능
일급 함수	변수에 저장, 인자/리턴값으로 사용 가능
클로저	내부 상태 유지 가능
가변 인자	...T 문법으로 처리
defer	종료 직전 실행, 리소스 정리에 필수
panic/recover	예외 복구 처리

 

 

메서드

✔  리시버

func (d Dog) info() int {
	return d.width * d.height
}

• d Dog 부분이 리시버 → info 메서드는 Dog 타입에 속함
• d는 구조체 변수로써 해당 메서드에서 매개변수처럼 사용됨
• 리시버로는 모든 로컬 타입들이 가능함 → 로컬 타입은 해당 패키지 안에서 type 키워드로 선언된 타입들
• 메서드 정의는 같은 패키지 내 어디에도 위치할 수 있지만 구조체가 선언된 파일 내에 메서드도 위치하는 것이 일반적
• 일반 함수는 어디에도 속하지 않지만 메서드는 리시버에 속함

 

✔  포인터 메서드 vs 값 타입 메서드

package main

import "fmt"

type account struct {
	balance int
	credit float64
	name string
}

func (a *account) withdrawPointer(amount int) {
	a.balance -= amount
}

func (a account) withdrawValue(amount int) {
	a.balance -= amount
}

func (a account) withdrawReturnValue(amount int) account {
	a.balance -= amount
	return a
}

func main() {
	mainA := account{balance: 100}
	fmt.Println(mainA.balance)
	
	mainA.withdrawPointer(10)
	fmt.Println(mainA.balance)

	mainA.withdrawValue(10)
	fmt.Println(mainA.balance)

	mainA = mainA.withdrawReturnValue(10)
	fmt.Println(mainA.balance)
}	

/*
100   초기값
90    포인터 메서드
90    값 메서드
80    값 반환 메서드
*/

✔  인터페이스와 함께 쓰기

type Shape interface {
    Area() float64
}

type Circle struct {
    Radius float64
}

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

✔  메서드 체이닝(포인터 리시버를 리턴해서 체이닝)

type Builder struct {
    data string
}

func (b *Builder) Add(s string) *Builder {
    b.data += s
    return b
}

func (b *Builder) Result() string {
    return b.data
}

res := (&Builder{}).Add("Hello, ").Add("Go!").Result()  // "Hello, Go!"

 

✔  데이터 은닉

type account struct {
    balance int
}

func NewAccount() *account {
    return &account{balance: 0}
}

func (a *account) Deposit(amount int) {
    if amount > 0 {
        a.balance += amount
    }
}

func (a *account) Balance() int {
    return a.balance
}

// 외부에서 balance 접근 불가

✔  메서드에서 인터페이스 타입 인자(다형성)

type Logger interface {
    Log(msg string)
}

type ConsoleLogger struct{}

func (c ConsoleLogger) Log(msg string) {
    fmt.Println("[LOG]", msg)
}

func process(l Logger) {
    l.Log("Starting process")
}

 

✅ 주요 특징

구분	설명
리시버(receiver)	메서드를 어떤 타입에 붙일지 정의
포인터 리시버	상태 변경 필요 시 사용
값 리시버	읽기 전용 처리 시 사용
체이닝	포인터 리턴하면 가능
인터페이스와 사용	다형성 구현 가능
임베딩	상속 유사 기능

 

 

인터페이스

✔  기본
- 메서드 구현을 포함한 구체화된 객체가 아닌 추상화된 객체로 상호작용할 수 있음
- 자바의 인터페이스 개념과 같음 → 메서드 기반 인터페이스
- 인터페이스는 다형성을 구현하기 위한 도구

type Logger interface {
    Log(msg string)
}

type FileLogger struct{}
func (f FileLogger) Log(msg string) {
    fmt.Println("[File]", msg)
}

type ConsoleLogger struct{}
func (c ConsoleLogger) Log(msg string) {
    fmt.Println("[Console]", msg)
}

func Process(logger Logger) {
    logger.Log("처리 시작")
    // ...
    logger.Log("처리 종료")
}

func main() {
    fileLogger := FileLogger{}
    consoleLogger := ConsoleLogger{}

    Process(fileLogger)
    Process(consoleLogger)
}

✔  의존성 주입(DI)
서비스 계층에서 의존성 분리

// 인터페이스 정의
type UserRepository interface {
    FindByID(id int) (*User, error)
}

// 실제 구현체
type MySQLUserRepository struct {
    db *sql.DB
}

func (r *MySQLUserRepository) FindByID(id int) (*User, error) {
    // DB에서 사용자 조회
    ...
}

// 서비스 계층
type UserService struct {
    repo UserRepository // 인터페이스에 의존
}

func (s *UserService) GetUser(id int) (*User, error) {
    return s.repo.FindByID(id)
}

// UserRepository에 대한 Mock을 만들어 단위 테스트를 쉽게 작성할 수 있음
// MySQL 외에 Redis, Memory 기반 등 다양한 구현체로 교체 가능

✔  빈 인터페이스 활용
빈 인터페이스는 템플릿 or 제네릭 처럼 어떤 타입이든 받아줄 수 있는 형태

// JSON 예제
var result map[string]interface{}
err := json.Unmarshal([]byte(jsonStr), &result)

fmt.Println(result["price"]) // float64, string 등 다양한 타입일 수 있음

// 컨테이너 자료구조 구현
type Stack struct {
    items []interface{}
}

func (s *Stack) Push(v interface{}) {
    s.items = append(s.items, v)
}

func (s *Stack) Pop() interface{} {
    if len(s.items) == 0 {
        return nil
    }
    last := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return last
}

• 주의사항
  • 타입 안정성 없음(잘못된 타입 → 패닉 발생 가능)
  • 남용 위험(모든 걸 interface{}로 처리하면 유지보수 악화)
• 대안: 제네릭(Go 1.18 이후)

type Stack[T any] struct {
    items []T
}

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

 

✔  any

• Go 1.18부터 도입된 제네릭 지원 타입
• type any = interface{}

var x any

x = 123
fmt.Println(x)

x = "hello"
fmt.Println(x)

 

✔  타입 스위치

var x any = "hello"

switch v := x.(type) {
case int:
    fmt.Println("정수:", v)
case string:
    fmt.Println("문자열:", v)
default:
    fmt.Println("알 수 없는 타입")
}

 

✔  특히 json 직렬화시 많이 사용

var data map[string]any
err := json.Unmarshal([]byte(jsonStr), &data)

 

✔  덕 타이핑
덕 타이핑(Duck Typing)은 “어떤 타입이 특정 메서드를 가지고 있다면, 그 타입은 해당 인터페이스를 구현한 것으로 간주한다”는 개념. Go에서는 명시적으로 implements 같은 키워드를 쓰지 않고도 암묵적으로 인터페이스를 만족

package main

import "fmt"

// 인터페이스 정의
type Walker interface {
    Walk()
}

// 타입 정의
type Dog struct{}

func (d Dog) Walk() {
    fmt.Println("Dog walks")
}

type Cat struct{}

func (c Cat) Walk() {
    fmt.Println("Cat walks")
}

// 인터페이스를 사용하는 함수
func StartWalking(w Walker) {
    w.Walk()
}

func main() {
    dog := Dog{}
    cat := Cat{}

    StartWalking(dog) // Dog는 명시적으로 Walker를 구현하지 않았지만 Walk() 메서드가 있으므로 사용 가능
    StartWalking(cat) // Cat도 마찬가지
}

 

 

에러 핸들링

✔  기본 Go 함수는 에러가 발생할 가능성이 있으면 보통 다음과 같이 error 타입을 함께 리턴

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}

result, err := divide(10, 2)
if err != nil {
    fmt.Println("Error:", err)
    return
}
fmt.Println("Result:", result)

✔  Error() 메서드를 구현하면 어떤 타입이든 error로 사용할 수 있음

type error interface {
    Error() string
}

✔  fmt.Errorf: 에러 포맷 생성

err := fmt.Errorf("파일 열기 실패: %v", err)

✔  사용자 정의 에러 타입

type MyError struct {
    Code int
    Msg  string
}

func (e MyError) Error() string {
    return fmt.Sprintf("Error %d: %s", e.Code, e.Msg)
}

return MyError{Code: 404, Msg: "Not Found"} // 실무 코드 기반(자주 사용됨)

✔  로그와 에러 분리 에러를 리턴하는 함수는 로그를 찍지 않고 호출자가 판단하도록 위임: 호출 측에서 log.Println(err) 또는 fmt.Println(err) 처리

func readFile(path string) ([]byte, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, fmt.Errorf("readFile: %w", err)
    }
    return data, nil
}

 

✅ 주요 특징

항목	설명
error 인터페이스	Error() string 메서드만 구현
fmt.Errorf	메시지 포함 에러 생성 (%w로 감싸기 가능)
errors.Is/As	에러 비교 및 다운캐스팅
panic/recover	치명적 상황 대비 (일반 로직에선 지양)
사용자 정의 에러 타입	실무 코드에서 상세한 에러 전달 가능
sentinel errors	고정된 에러 값으로 상태 구분
early return 패턴	코드 가독성 확보에 중요