Kes penggunaan khas dan teknik generik dalam golang

Kes dan helah penggunaan khas untuk generik dalam Go Gunakan antara muka jenis kosong untuk semakan jenis dinamik untuk menyemak jenis masa jalan. Gunakan parameter jenis generik dalam koleksi untuk mencipta bekas pelbagai jenis. Laksanakan kaedah generik untuk melaksanakan operasi biasa untuk pelbagai jenis parameter. Gunakan kekangan jenis untuk melaksanakan generik khusus jenis dan menyesuaikan operasi untuk jenis tertentu.

Kes Penggunaan Khas dan Petua untuk Generik dalam Go

Generik memperkenalkan ciri baharu yang membolehkan anda menulis kod yang fleksibel dan cekap. Artikel ini akan meneroka kes dan teknik penggunaan khas untuk generik dalam Go.

1. Gunakan antara muka jenis kosong untuk semakan jenis dinamik

any Jenis boleh mewakili sebarang jenis. Ini membolehkan kami melakukan semakan jenis dinamik berdasarkan jenis yang ditentukan semasa masa jalan.

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. Menggunakan jenis generik pada koleksi

Parameter jenis generik boleh digunakan dalam jenis koleksi untuk mencipta bekas pelbagai jenis.

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. Laksanakan kaedah generik

Kaedah generik membolehkan kami melaksanakan operasi biasa untuk pelbagai jenis parameter.

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. Laksanakan generik khusus jenis menggunakan kekangan jenis

Kekangan jenis mengehadkan skop jenis generik. Ia membolehkan kami melaksanakan operasi tersuai untuk jenis tertentu.

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}]
}

Kes dan teknik penggunaan khas ini menunjukkan kuasa generik dalam Go, membolehkan penciptaan kod yang lebih serba boleh, fleksibel dan cekap.

Atas ialah kandungan terperinci Kes penggunaan khas dan teknik generik dalam golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!