golang의 제네릭의 특수 사용 사례 및 기술

Go의 제네릭에 대한 특수 사용 사례 및 요령 런타임 유형을 확인하려면 동적 유형 검사에 빈 유형 인터페이스를 사용하세요. 컬렉션에 일반 유형 매개변수를 사용하여 다양한 유형의 컨테이너를 만듭니다. 다양한 유형의 매개변수에 대해 공통 작업을 수행하는 일반 메서드를 구현합니다. 유형 제약 조건을 사용하여 유형별 제네릭을 구현하고 지정된 유형에 대한 작업을 사용자 정의합니다.

Go의 제네릭에 대한 특수 사용 사례 및 팁

Generics는 유연하고 효율적인 코드를 작성할 수 있게 해주는 새로운 기능을 소개합니다. 이 기사에서는 Go의 제네릭에 대한 특별한 사용 사례와 기술을 살펴보겠습니다.

1. 동적 유형 검사를 위해 빈 유형 인터페이스를 사용합니다.

any 유형은 모든 유형을 나타낼 수 있습니다. 이를 통해 런타임에 결정된 유형을 기반으로 동적 유형 검사를 수행할 수 있습니다.

func isString(v any) bool {
    _, ok := v.(string)
    return ok
}

func main() {
    x := "hello"
    y := 10
    fmt.Println(isString(x)) // true
    fmt.Println(isString(y)) // false
}

2. 컬렉션에 일반 유형 사용

일반 유형 매개변수를 컬렉션 유형에 사용하여 다양한 유형의 컨테이너를 만들 수 있습니다.

type Stack[T any] []T

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

func (s *Stack[T]) Pop() T {
    if s.IsEmpty() {
        panic("stack is empty")
    }

    v := (*s)[len(*s)-1]
    *s = (*s)[:len(*s)-1]
    return v
}

func main() {
    s := new(Stack[int])
    s.Push(10)
    s.Push(20)
    fmt.Println(s.Pop()) // 20
    fmt.Println(s.Pop()) // 10
}

3. 일반 메서드 구현

일반 메서드를 사용하면 다양한 유형의 매개변수에 대한 공통 작업을 구현할 수 있습니다.

type Num[T numeric] struct {
    V T
}

func (n *Num[T]) Add(other *Num[T]) {
    n.V += other.V
}

func main() {
    n1 := Num[int]{V: 10}
    n2 := Num[int]{V: 20}
    n1.Add(&n2)
    fmt.Println(n1.V) // 30

    // 可以使用其他数字类型
    n3 := Num[float64]{V: 3.14}
    n4 := Num[float64]{V: 2.71}
    n3.Add(&n4)
    fmt.Println(n3.V) // 5.85
}

4. 유형 제약 조건을 사용하여 유형별 제네릭을 구현합니다.

유형 제약 조건은 제네릭 유형의 범위를 제한합니다. 이를 통해 특정 유형에 대한 사용자 정의 작업을 구현할 수 있습니다.

type Comparer[T comparable] interface {
    CompareTo(T) int
}

type IntComparer struct {
    V int
}

func (c *IntComparer) CompareTo(other IntComparer) int {
    return c.V - other.V
}

// IntSlice 实现 Comparer[IntComparer] 接口
type IntSlice []IntComparer

func (s IntSlice) Len() int {
    return len(s)
}

func (s IntSlice) Less(i, j int) bool {
    return s[i].CompareTo(s[j]) < 0
}

func (s IntSlice) Swap(i, j int) {
    s[i], s[j] = s[j], s[i]
}

func main() {
    s := IntSlice{{10}, {20}, {5}}
    sort.Sort(s)
    fmt.Println(s) // [{5} {10} {20}]
}

이 특별한 사용 사례와 기술은 Go에서 제네릭의 힘을 보여줌으로써 보다 다양하고 유연하며 효율적인 코드를 생성할 수 있게 해줍니다.

위 내용은 golang의 제네릭의 특수 사용 사례 및 기술의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!