0Pricing
Go Academy · Leçon

Les génériques en pratique : pièges

Savoir quand utiliser les génériques et éviter les erreurs courantes

Les génériques en pratique : pièges est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

Généralisation excessive des génériques

Toutes les fonctions n'ont pas besoin d'être génériques. Si un seul type concret est utilisé, une fonction générique ajoute de la complexité sans apporter de bénéfice. Préférez les types concrets et passez aux génériques lorsque des duplications apparaissent.

Assertion de type dans les génériques

Vous ne pouvez pas effectuer d'assertion de type ni de commutateur de type dans une fonction générique sur le paramètre de type lui-même — les génériques ne sont pas des modèles. Utilisez plutôt des interfaces ou le paquet reflect.

// WRONG:
func Foo[T any](v T) {
    if x, ok := v.(int); ok { // compile error
    }
}

Comparable ne signifie pas Ordered

comparable prend uniquement en charge ==. Pour utiliser < et >, vous avez besoin de cmp.Ordered ou d'une contrainte personnalisée. Une erreur courante consiste à supposer que comparable couvre l'ordre.

Une méthode ne peut pas introduire de paramètres de type

Les méthodes des types génériques réutilisent les paramètres du type, mais ne peuvent pas en ajouter de nouveaux. Si une méthode nécessite un paramètre de type supplémentaire, utilisez plutôt une fonction de niveau supérieur.

// WRONG:
func (s *Stack[T]) MapTo[U any]() []U // compile error

Valeurs nil et valeurs nulles

Pour les paramètres de type pointeur, la valeur nulle est nil. Pour les types valeur, il s'agit de la valeur nulle du type. Gérez toujours le cas nul au lieu de supposer que la valeur n'est pas nil.

Ensembles de méthodes d'interface et génériques

Une fonction générique contrainte par une interface ne peut appeler que les méthodes déclarées dans cette interface. Ajouter des méthodes à un type concret ne les rend pas disponibles par l'intermédiaire de la contrainte.

Gonflement lié aux instanciations (formes GC)

Go partage les implémentations pour les types ayant la même forme GC (par exemple, tous les types pointeur partagent une implémentation). Les types primitifs disposent chacun de leur propre implémentation, mais l'approche de Go maintient une taille de binaire raisonnable.

any n'est pas interface{}

any est un alias de interface{}, mais une fonction générique F[T any] n'est pas équivalente à F(v interface{}) : dans la fonction générique, T est le type concret au point d'appel, ce qui préserve les informations de type.

Types génériques récursifs

Go ne prend pas en charge les définitions récursives de paramètres de type telles que type Tree[T Tree[T]]. Utilisez plutôt la composition :

type TreeNode[T any] struct {
    Val   T
    Left  *TreeNode[T]
    Right *TreeNode[T]
}

Auxiliaires préinstanciés

Pour le code sensible aux performances, préinstanciez les fonctions génériques fréquemment utilisées en tant que fonctions de niveau supérieur afin d'éviter le coût répété de l'inférence de type (même si le compilateur Go gère très bien ce cas).

Tester le code générique

Testez les fonctions génériques avec plusieurs instanciations : une pour chaque contrainte distincte (int, string, un type personnalisé). Cela permet de détecter les cas limites propres à chaque contrainte.

func TestMap(t *testing.T) {
    got := Map([]int{1,2}, double)
    // test with strings too
    gotS := Map([]string{"a","b"}, strings.ToUpper)
}

Vérification rapide

Pourquoi ne pouvez-vous PAS effectuer de commutateur de type sur un paramètre de type générique T dans une fonction générique ?

Récapitulatif : pièges des génériques

Points clés :

  • Ne généralisez pas excessivement ; les types concrets sont plus simples lorsqu'ils ne sont utilisés qu'une seule fois
  • Aucun commutateur ni assertion de type sur T dans les fonctions génériques
  • comparable ≠ ordonné ; utilisez cmp.Ordered pour prendre en charge <
  • Les méthodes ne peuvent pas introduire de nouveaux paramètres de type

Questions Fréquemment Posées

La leçon « Les génériques en pratique : pièges » est-elle gratuite ?

Oui — le texte complet de « Les génériques en pratique : pièges » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Les génériques en pratique : pièges » ?

Savoir quand utiliser les génériques et éviter les erreurs courantes Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Go Academy ?

Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Les génériques en pratique : pièges » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?

Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Syntaxe des paramètres de type
  2. Contraintes : comparable et interfaces
  3. Structures de données génériques
  4. Les génériques en pratique : pièges
← Retour à Go Academy