Kesan pengaturcaraan generik Golang pada lulus parameter

Pengaturcaraan generik dalam Go 1.18 memperkenalkan perubahan lulus parameter berikut: Jenis inferens: Pengkompil secara automatik menyimpulkan fungsi generik dan parameter jenis tanpa perlu menentukannya secara manual. Semantik nilai: Fungsi generik beroperasi pada nilai dan tidak mengubah suai pembolehubah asal. Penggunaan semula kod universal: Pengaturcaraan generik membolehkan penggunaan semula kod dengan membenarkan penciptaan fungsi dan jenis universal yang boleh mengendalikan sebarang jenis data.

Impak Pengaturcaraan Generik dalam Go on Parameter Passing

Selepas pengenalan pengaturcaraan generik dalam Go 1.18, lulus parameter telah mengalami perubahan ketara. Fungsi dan jenis generik kini boleh menerima sebarang jenis hujah, yang membawa kepada perubahan besar dalam cara hujah diluluskan dan digunakan.

Inferens Jenis

Pengaturcaraan generik Go menghapuskan keperluan untuk menentukan parameter jenis secara eksplisit dalam panggilan fungsi. Pengkompil kini boleh membuat kesimpulan secara automatik jenis yang betul, yang menjadikan kod lebih ringkas dan boleh dibaca.

Contohnya:

// 使用泛型类型
func Max[T any](a, b T) T {
    if a > b {
        return a
    }
    return b
}

Apabila memanggil fungsi Max, pengkompil boleh membuat kesimpulan bahawa a dan b adalah daripada jenis int </ code>, tidak perlu menyatakannya secara eksplisit: <code>Max 函数时，编译器可以推断出 a 和 b 类型为 int，无需显式指定：

result := Max(10, 5) // result 类型自动推断为 int

值语义

与 Java 等其他语言中的泛型不同，Go 中的泛型函数是对值进行操作的。这意味着函数不会修改原始参数值，而是返回一个带有修改后值的新变量。

例如：

func Increment[T any](x *T) {
    *x++
}

在这个例子中，Increment 函数对 x 的 值 进行递增操作，而不是原始变量本身。

实战案例

案例 1：使用泛型函数排序切片

使用泛型编程，我们可以创建通用的 Sort

func Sort[T comparable](arr []T) {
    for i := 0; i < len(arr)-1; i++ {
        for j := i + 1; j < len(arr); j++ {
            if arr[i] > arr[j] {
                arr[i], arr[j] = arr[j], arr[i]
            }
        }
    }
}

Tidak seperti generik dalam bahasa lain seperti Java, fungsi generik dalam Go beroperasi pada nilai. Ini bermakna fungsi itu tidak mengubah suai nilai parameter asal, tetapi mengembalikan pembolehubah baharu dengan nilai yang diubah suai.

type Queue[T any] struct {
    data []T
}

func (q *Queue[T]) Enqueue(item T) {
    q.data = append(q.data, item)
}

func (q *Queue[T]) Dequeue() T {
    if len(q.data) == 0 {
        return zeroValue[T]() // 返回 T 类型的零值
    }
    item := q.data[0]
    q.data = q.data[1:]
    return item
}

Salin selepas log masuk

Dalam contoh ini, fungsi Tambahan menambah nilai x dan bukannya pembolehubah asal itu sendiri. Kes praktikal : Mencipta baris gilir generik menggunakan jenis generik

rrreee🎜Kesimpulan🎜🎜Go Pengaturcaraan generik mentakrifkan semula lulus parameter dengan menghapuskan spesifikasi jenis, memaksa semantik nilai dan mendayakan penggunaan semula kod universal. Ini meningkatkan kebolehbacaan kod, kebolehselenggaraan dan fleksibiliti, dengan itu memperluaskan kemungkinan bahasa Go. 🎜

Atas ialah kandungan terperinci Kesan pengaturcaraan generik Golang pada lulus parameter. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!