👨‍💻 [Go] Go 에서 채택하고 있는 덕 타이핑(Duck Typing) 이란 무엇이며, 어떻게 활용할 수 있나요?

👨‍💻 안녕하세요, 윌리 프로젝트의 윌리 입니다.

Go 에서 채택하고 있는 덕 타이핑(Duck Typing) 이란 무엇이며, 어떻게 활용할 수 있는지 간략히 알아보았습니다.

---

질문 >

Go 에서 채택하고 있는 덕 타이핑(Duck Typing) 이란 무엇이며, 어떻게 활용할 수 있나요?

답변 >

Go 언어에서 덕 타이핑(Duck Typing)은 명시적인 상속이나 구현 없이도 객체가 특정 메서드 집합을 가지고 있다면 해당 인터페이스를 구현한 것으로 간주하는 방식을 의미합니다. Go는 이를 통해 유연하고 간결한 코드 작성을 지원합니다. "덕 타이핑"이라는 이름은 다음 말에서 유래되었습니다:

"If it looks like a duck, swims like a duck, and quacks like a duck, then it is probably a duck."

즉, 객체의 실제 타입이 아닌, 객체가 가진 메서드에 따라 타입이 결정된다는 개념입니다.

Go에서 덕 타이핑과 인터페이스

Go에서는 인터페이스가 덕 타이핑의 핵심입니다. 인터페이스는 특정 메서드 집합을 정의하며, 어떤 구조체나 타입이 해당 인터페이스의 메서드를 모두 구현하면 명시적인 선언 없이도 그 인터페이스를 구현한 것으로 간주됩니다.

예제 1: 기본적인 덕 타이핑

package main

import "fmt"

// 인터페이스 정의
type Quacker interface {
    Quack()
}

// 구조체 정의
type Duck struct{}

func (d Duck) Quack() {
    fmt.Println("Quack!")
}

type Person struct{}

func (p Person) Quack() {
    fmt.Println("I'm pretending to be a duck!")
}

func main() {
    // Duck과 Person 모두 Quacker 인터페이스를 구현
    var q Quacker

    d := Duck{}
    q = d
    q.Quack() // 출력: Quack!

    p := Person{}
    q = p
    q.Quack() // 출력: I'm pretending to be a duck!
}

• Duck과 Person 구조체는 Quacker 인터페이스를 명시적으로 구현하지 않았지만, Quack() 메서드를 가지고 있으므로 Quacker 인터페이스를 만족합니다.

---

덕 타이핑의 장점

1. 유연한 코드: 타입 간의 강한 결합을 피하면서도 다양한 객체를 처리할 수 있습니다.
2. 간결함: 명시적인 선언 없이 인터페이스를 구현할 수 있어 코드가 간결합니다.
3. 확장성: 새로운 타입을 추가할 때 기존 인터페이스에 맞게 메서드만 정의하면 인터페이스를 만족시킬 수 있습니다.

---

활용 예제

예제 2: 다형성을 활용한 함수 설계

package main

import "fmt"

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

// 구조체 정의
type Circle struct {
    Radius float64
}

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

type Rectangle struct {
    Width, Height float64
}

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

// 인터페이스를 사용하는 함수
func PrintArea(s Shape) {
    fmt.Printf("Area: %.2f\\n", s.Area())
}

func main() {
    c := Circle{Radius: 5}
    r := Rectangle{Width: 4, Height: 6}

    // Circle과 Rectangle이 Shape 인터페이스를 구현
    PrintArea(c) // 출력: Area: 78.50
    PrintArea(r) // 출력: Area: 24.00
}

• Circle과 Rectangle은 Shape 인터페이스의 Area() 메서드를 구현했으므로, PrintArea 함수에서 공통적으로 처리됩니다.

---

예제 3: 빈 인터페이스 (interface{})와 덕 타이핑

Go의 빈 인터페이스 (interface{})는 모든 타입을 나타낼 수 있어 덕 타이핑의 유연성을 극대화합니다.

package main

import "fmt"

func PrintAnything(v interface{}) {
    fmt.Printf("Value: %v, Type: %T\\n", v, v)
}

func main() {
    PrintAnything(42)          // 출력: Value: 42, Type: int
    PrintAnything("Hello")     // 출력: Value: Hello, Type: string
    PrintAnything(3.14)        // 출력: Value: 3.14, Type: float64
    PrintAnything([]int{1, 2}) // 출력: Value: [1 2], Type: []int
}

• interface{}는 모든 타입을 수용할 수 있지만, 타입 안전성을 보장하지 않으므로 타입 단언(type assertion)이나 타입 스위치(type switch)가 필요할 수 있습니다.

---

예제 4: 컨텍스트 기반 동작

덕 타이핑은 다양한 타입에 대해 일관된 동작을 제공하는 컨텍스트에서 매우 유용합니다.

package main

import "fmt"

// 인터페이스 정의
type Speaker interface {
    Speak()
}

// 여러 구조체 정의
type Dog struct{}

func (d Dog) Speak() {
    fmt.Println("Woof!")
}

type Cat struct{}

func (c Cat) Speak() {
    fmt.Println("Meow!")
}

type Robot struct{}

func (r Robot) Speak() {
    fmt.Println("Beep!")
}

// 인터페이스를 사용하는 함수
func PerformSpeak(s Speaker) {
    s.Speak()
}

func main() {
    PerformSpeak(Dog{})   // 출력: Woof!
    PerformSpeak(Cat{})   // 출력: Meow!
    PerformSpeak(Robot{}) // 출력: Beep!
}

• Dog, Cat, Robot은 Speaker 인터페이스를 명시적으로 구현하지 않았지만, Speak 메서드를 가지고 있으므로 덕 타이핑을 통해 같은 인터페이스로 처리됩니다.

---

주의 사항

1. 타입 안전성:
   • 덕 타이핑은 컴파일 타임에 타입을 검증하기 때문에 런타임 오류를 줄일 수 있습니다.
   • 그러나 interface{}를 사용할 때는 타입 단언이나 타입 스위치를 사용해야 안전하게 처리할 수 있습니다.
2. 메서드 충돌:
   • 인터페이스에서 정의한 메서드와 동일한 이름의 메서드가 있다면, 의도치 않게 인터페이스를 구현하게 될 수 있습니다.

---

결론

Go의 덕 타이핑은 인터페이스를 통해 명시적인 상속이나 구현 없이도 타입의 행동을 정의하고 사용할 수 있게 해줍니다. 이를 통해 코드의 유연성과 재사용성을 높일 수 있으며, 다양한 상황에서 활용 가능합니다. interface와 함께 덕 타이핑을 효과적으로 사용하면 간결하고 확장성 있는 Go 프로그램을 작성할 수 있습니다.

---

"이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."

---

🎬 유튜브 채널 🎬

위로그@WiLog

🎬 치지직 채널 🎬

위로그 채널 - CHZZK

---