Fahami konsep teras generik Golang

Go generik membenarkan penciptaan jenis dan fungsi yang boleh diguna semula tanpa mengubah suai kod itu sendiri. Ia termasuk: Jenis generik: Gunakan parameter jenis, membenarkan jenis parameter ditentukan semasa membuat jenis (seperti []T, peta[K]V). Fungsi generik: Apabila menggunakan parameter jenis, senarai parameter jenis eksplisit mesti ditentukan. Kekangan: Hadkan penggunaan jenis generik Gunakan kata kunci mana-mana, setanding dan antara muka jenis untuk menentukan sekatan jenis pada parameter jenis. Dengan konsep ini, adalah mungkin untuk mencipta kod yang lebih mantap dan tujuan umum, seperti algoritma pengisihan generik.

Fahami konsep teras Golang generik

Preface
Generik ialah ciri baharu yang penting yang diperkenalkan dalam Go 1.18, yang membolehkan kami mencipta jenis boleh guna semula dengan sendirinya tanpa mengubah suai kod. Tutorial ini akan memperkenalkan konsep teras generik dalam Go dan menunjukkan penggunaannya melalui contoh praktikal.

Jenis generik
Jenis generik menentukan jenis parameter, membolehkan kami menentukan jenis parameter semasa mencipta jenis. Ini boleh dicapai dengan menggunakan pencipta jenis seperti []T atau map[K]V, di mana T dan V code> ialah jenis nilai dan jenis kunci masing-masing. <code>[]T 或 map[K]V 等类型创建器来实现，其中 T 和 V 分别是值类型和键类型。

// 定义一个泛型 slice 类型
type MySlice[T any] []T

// 创建一个 MySlice[int] 实例
s := MySlice[int]{1, 2, 3}

泛型函数
泛型函数也可以使用类型参数，但它们还必须指定显式的类型参数列表。

// 定义一个将切片元素加倍的泛型函数
func Double[T ~int | ~float64](s []T) []T {
  for i, v := range s {
    s[i] = v * 2
  }
  return s
}

约束
约束允许我们通过指定类型参数的类型限制来限制泛型类型的用法。约束使用关键字 any、comparable

// 定义一个泛型 map 类型，键值为可比较类型
type MyMap[K comparable, V any] map[K]V

// 定义一个泛型函数来查找切片中的最大值
func Max[T any](s []T) T where T: ~int | ~float64 {
  max := s[0]
  for _, v := range s {
    if v > max {
      max = v
    }
  }
  return max
}

Fungsi generikFungsi generik juga boleh mengambil parameter jenis, tetapi ia juga mesti menyatakan senarai parameter jenis eksplisit.

// 定义泛型交换函数
func Swap[T any](s []T, i, j int) {
  temp := s[i]
  s[i] = s[j]
  s[j] = temp
}

// 定义泛型排序函数
func Sort[T any](s []T) where T: ~int | ~float64 | ~string {
  for i := 0; i < len(s); i++ {
    for j := i + 1; j < len(s); j++ {
      if s[j] < s[i] {
        Swap(s, i, j)
      }
    }
  }
}

KekanganKekangan membolehkan kami mengehadkan penggunaan jenis generik dengan menyatakan sekatan jenis pada parameter jenis. Kekangan dilaksanakan menggunakan kata kunci mana-mana, comparable dan antara muka jenis.

rrreee

Contoh Praktikal🎜🎜Mari kita bina algoritma pengisihan mudah menggunakan generik: 🎜rrreee🎜🎜Kesimpulan🎜🎜🎜Generics dalam Go menyediakan alat yang berkuasa untuk penggunaan semula kod dan fleksibiliti. Dengan memahami parameterisasi jenis, kekangan dan contoh praktikal, pembangun boleh memanfaatkan ciri ini untuk mencipta kod yang lebih mantap dan serba boleh. 🎜

Atas ialah kandungan terperinci Fahami konsep teras generik Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!