Go s Generics : écrire un code plus intelligent qui fonctionne avec plusieurs types-Golang-php.cn

Go s Generics: Writing Smarter Code That Works with Multiple Types

Les génériques arrivent sur Go, et c'est un gros problème. J'ai étudié les modifications proposées pour Go 2 et je suis ravi de partager ce que j'ai appris sur cette nouvelle fonctionnalité puissante.

À la base, les génériques nous permettent d'écrire du code qui fonctionne avec plusieurs types. Au lieu d'écrire des fonctions distinctes pour les entiers, les chaînes et les types personnalisés, nous pouvons écrire une seule fonction générique qui les gère tous. Cela conduit à un code plus flexible et réutilisable.

Commençons par un exemple basique. Voici comment nous pourrions écrire une fonction générique "Max":

func Max[T constraints.Ordered](a, b T) T {
    if a > b {
        return a
    }
    return b
}

Copier après la connexion

Cette fonction fonctionne avec tout type T qui satisfait la contrainte Ordonné. Nous pouvons l'utiliser avec des entiers, des flottants, des chaînes ou tout type personnalisé qui implémente des opérateurs de comparaison.

Les contraintes de type sont une partie cruciale de l'implémentation des génériques de Go. Ils nous permettent de spécifier quelles opérations nos types génériques doivent prendre en charge. Le package de contraintes fournit plusieurs contraintes prédéfinies, mais nous pouvons également créer les nôtres.

Par exemple, nous pourrions définir une contrainte pour les types pouvant être convertis en chaînes :

type Stringer interface {
    String() string
}

Copier après la connexion

Nous pouvons désormais écrire des fonctions qui fonctionnent avec n'importe quel type pouvant être converti en chaîne :

func PrintAnything[T Stringer](value T) {
    fmt.Println(value.String())
}

Copier après la connexion

L'un des aspects intéressants des génériques de Go est l'inférence de type. Dans de nombreux cas, nous n'avons pas besoin de spécifier explicitement les paramètres de type lors de l'appel d'une fonction générique. Le compilateur peut le comprendre :

result := Max(5, 10) // Type inferred as int

Copier après la connexion

Cela permet de garder notre code propre et lisible, tout en offrant les avantages des génériques.

Entrons dans un territoire plus avancé. Les listes de paramètres de type nous permettent de spécifier des relations entre plusieurs paramètres de type. Voici un exemple de fonction qui convertit entre deux types :

func Convert[From, To any](value From, converter func(From) To) To {
    return converter(value)
}

Copier après la connexion

Cette fonction prend une valeur de n'importe quel type, une fonction de convertisseur, et renvoie la valeur convertie. Il est incroyablement flexible et peut être utilisé dans de nombreux scénarios différents.

Les génériques brillent vraiment en matière de structures de données. Implémentons une pile générique simple :

type Stack[T any] struct {
    items []T
}

func (s *Stack[T]) Push(item T) {
    s.items = append(s.items, item)
}

func (s *Stack[T]) Pop() (T, bool) {
    if len(s.items) == 0 {
        var zero T
        return zero, false
    }
    item := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return item, true
}

Copier après la connexion

Cette pile peut contenir tout type d’objet. Nous pouvons créer des piles d'entiers, de chaînes ou de structures personnalisées, le tout avec le même code.

Les génériques ouvrent également de nouvelles possibilités pour les modèles de conception dans Go. Par exemple, nous pouvons implémenter un modèle d'observateur générique :

type Observable[T any] struct {
    observers []func(T)
}

func (o *Observable[T]) Subscribe(f func(T)) {
    o.observers = append(o.observers, f)
}

func (o *Observable[T]) Notify(data T) {
    for _, f := range o.observers {
        f(data)
    }
}

Copier après la connexion

Cela nous permet de créer des objets observables pour tout type de données, ce qui facilite la mise en œuvre d'architectures événementielles.

Lors de la refactorisation du code Go existant pour utiliser des génériques, il est important de trouver un équilibre. Si les génériques peuvent rendre notre code plus flexible et réutilisable, ils peuvent également le rendre plus complexe et plus difficile à comprendre. J'ai trouvé qu'il est souvent préférable de commencer par des mises en œuvre concrètes et d'introduire des génériques uniquement lorsque nous constatons des schémas clairs de répétition.

Par exemple, si nous nous retrouvons à écrire des fonctions similaires pour différents types, c'est un bon candidat pour la générification. Mais si une fonction n'est utilisée qu'avec un seul type, il est probablement préférable de la laisser telle quelle.

Un domaine dans lequel les génériques brillent vraiment est celui de la mise en œuvre d'algorithmes. Regardons une implémentation générique de tri rapide :

func Max[T constraints.Ordered](a, b T) T {
    if a > b {
        return a
    }
    return b
}

Copier après la connexion

Cette fonction peut trier des tranches de n'importe quel type ordonné. Nous pouvons l'utiliser pour trier des entiers, des flottants, des chaînes ou tout type personnalisé qui implémente des opérateurs de comparaison.

Lorsque vous travaillez avec des génériques dans des projets à grande échelle, il est crucial de réfléchir aux compromis entre la flexibilité et la vérification de type au moment de la compilation. Si les génériques nous permettent d'écrire du code plus flexible, ils peuvent également faciliter l'introduction d'erreurs d'exécution si nous n'y prenons pas garde.

Une stratégie que j'ai trouvée utile consiste à utiliser des génériques pour le code de bibliothèque interne, mais à exposer des types concrets dans les API publiques. Cela nous offre les avantages de la réutilisation du code en interne, tout en fournissant une interface claire et sécurisée aux utilisateurs de notre bibliothèque.

Une autre considération importante est la performance. Bien que l'implémentation des génériques par Go soit conçue pour être efficace, il peut toujours y avoir une certaine surcharge d'exécution par rapport aux types concrets. Dans le code critique en termes de performances, il peut être utile de comparer les implémentations génériques et non génériques pour voir s'il existe une différence significative.

Les génériques ouvrent également de nouvelles possibilités de métaprogrammation dans Go. Nous pouvons écrire des fonctions qui opèrent sur les types eux-mêmes, plutôt que sur les valeurs. Par exemple, nous pourrions écrire une fonction qui génère un nouveau type de structure au moment de l'exécution :

type Stringer interface {
    String() string
}

Copier après la connexion

Cette fonction crée un nouveau type de structure avec des champs de type T. C'est un outil puissant pour créer des structures de données dynamiques au moment de l'exécution.

En conclusion, il convient de noter que même si les génériques sont une fonctionnalité puissante, ils ne constituent pas toujours la meilleure solution. Parfois, des interfaces simples ou des types concrets sont plus appropriés. La clé est d'utiliser judicieusement les génériques, lorsqu'ils offrent des avantages évidents en termes de réutilisation du code et de sécurité des types.

Les génériques dans Go 2 représentent une évolution significative du langage. Ils fournissent de nouveaux outils pour écrire du code flexible et réutilisable tout en maintenant l'accent mis par Go sur la simplicité et la lisibilité. Alors que nous continuons à explorer et à expérimenter cette fonctionnalité, j'ai hâte de voir comment elle façonnera l'avenir de la programmation Go.