L'impact de la programmation générique Golang sur le passage des paramètres

La programmation générique dans Go 1.18 introduit les modifications de passage de paramètres suivantes : Inférence de type : le compilateur déduit automatiquement les fonctions génériques et les paramètres de type sans avoir à les spécifier manuellement. Sémantique des valeurs : Les fonctions génériques opèrent sur des valeurs et ne modifient pas les variables d'origine. Réutilisation universelle du code : la programmation générique permet la réutilisation du code en permettant la création de fonctions et de types universels capables de gérer tout type de données.

Impact de la programmation générique dans Go sur le passage de paramètres

Après l'introduction de la programmation générique dans Go 1.18, le passage de paramètres a subi des changements importants. Les fonctions et types génériques peuvent désormais accepter des arguments de tout type, ce qui entraîne un changement majeur dans la manière dont les arguments sont transmis et utilisés.

Type Inference

La programmation générique de Go élimine le besoin de spécifier explicitement les paramètres de type dans les appels de fonction. Le compilateur peut désormais déduire automatiquement les types corrects, ce qui rend le code plus concis et plus lisible.

Par exemple :

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

Lors de l'appel de la fonction Max, le compilateur peut en déduire que a et b sont de type int , pas besoin de le préciser explicitement : 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]
            }
        }
    }
}

Sémantique des valeurs

Contrairement aux génériques d'autres langages comme Java, les fonctions génériques de Go opèrent sur des valeurs. Cela signifie que la fonction ne modifie pas la valeur du paramètre d'origine, mais renvoie une nouvelle variable avec la valeur modifiée.

Exemple :

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
}

Dans cet exemple, la fonction Increment incrémente la valeur de x plutôt que la variable d'origine elle-même.

Cas pratique🎜🎜🎜Cas 1 : Tri de tranches à l'aide de fonctions génériques🎜🎜🎜Grâce à la programmation générique, on peut créer une fonction générale Tri pour trier des éléments comparables de tout type : 🎜rrreee 🎜🎜Cas 2 : Création d'une file d'attente générique à l'aide de types génériques🎜🎜rrreee🎜Conclusion🎜🎜Go La programmation générique redéfinit le passage des paramètres en éliminant la spécification de type, en forçant la sémantique des valeurs et en permettant la réutilisation universelle du code. Cela améliore la lisibilité, la maintenabilité et la flexibilité du code, élargissant ainsi les possibilités du langage Go. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!