Go Academy · Leçon

Syntaxe des paramètres de type

Fonctions et types génériques avec [T any]

Syntaxe des paramètres de type est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Contexte des génériques

Avant Go 1.18, le code fonctionnant avec plusieurs types nécessitait soit interface{}/any (avec une perte de sûreté de typage), soit une génération de code. Les génériques ajoutent des paramètres de type pour fournir un polymorphisme à la compilation.

Syntaxe des fonctions génériques

Déclarez les paramètres de type entre crochets après le nom de la fonction :

func Map[T, U any](s []T, f func(T) U) []U {
    result := make([]U, len(s))
    for i, v := range s {
        result[i] = f(v)
    }
    return result
}

nums := Map([]int{1,2,3}, func(n int) string {
    return strconv.Itoa(n)
})

Inférence de type

Dans la plupart des cas, le compilateur déduit les arguments de type à partir des arguments de la fonction. Vous pouvez les indiquer explicitement si l’inférence échoue.

// Inferred:
nums := Map([]int{1,2,3}, strconv.Itoa)
// Explicit:
nums := Map[int, string]([]int{1,2,3}, strconv.Itoa)

Types génériques

Les structures et les autres types peuvent également posséder des paramètres de type :

type Stack[T any] struct {
    items []T
}
func (s *Stack[T]) Push(v T) { s.items = append(s.items, v) }
func (s *Stack[T]) Pop() (T, bool) {
    if len(s.items) == 0 { var zero T; return zero, false }
    n := len(s.items)-1
    v := s.items[n]
    s.items = s.items[:n]
    return v, true
}

Plusieurs paramètres de type

Les fonctions et les types peuvent posséder plusieurs paramètres de type :

type Pair[K, V any] struct { Key K; Value V }

func Zip[K, V any](keys []K, vals []V) []Pair[K, V] {
    result := make([]Pair[K, V], min(len(keys), len(vals)))
    for i := range result {
        result[i] = Pair[K, V]{keys[i], vals[i]}
    }
    return result
}

Valeur zéro d’un paramètre de type

Déclarez une variable contenant la valeur zéro avec var zero T. Cette déclaration est nécessaire pour renvoyer un résultat « aucune valeur » depuis une fonction générique.

func First[T any](s []T) (T, bool) {
    if len(s) == 0 { var zero T; return zero, false }
    return s[0], true
}

Méthodes sur les types génériques

Les méthodes d’un type générique utilisent les paramètres de ce type, et non les leurs. Une méthode ne peut pas introduire de paramètres de type supplémentaires.

type Pair[K, V any] struct{ K K; V V }
func (p Pair[K, V]) Swap() Pair[V, K] { return Pair[V, K]{p.V, p.K} }

Instantiation

L’utilisation d’un type générique avec un argument de type concret s’appelle une instantiation. Elle se produit à la compilation, et non à l’exécution : il n’y a aucun coût lié à l’encapsulation.

s := Stack[int]{}
s.Push(42)

Alias de type et types génériques

Vous pouvez créer des alias de type pour des types génériques instanciés :

type IntStack = Stack[int]

Limitations

Les paramètres de type ne peuvent pas être utilisés avec les commutateurs de type ou les assertions de type. Les méthodes des types génériques ne peuvent pas posséder de paramètres de type supplémentaires. Les génériques ne peuvent pas être utilisés avec des types surchargés par opérateur sans contraintes.

Quand utiliser les génériques

Utilisez les génériques pour les algorithmes réellement indépendants des types (types conteneurs, assistants fonctionnels tels que Map/Filter/Reduce) lorsque l’alternative serait de dupliquer le code ou d’effectuer des conversions non sûres.

Vérification rapide

Où les paramètres de type sont-ils déclarés dans une fonction générique ?

Récapitulatif : syntaxe des paramètres de type

Points clés :

Paramètres de type entre crochets : func Foo[T any](...)
Fonctionne avec les fonctions et les types (structures, etc.)
Dans la plupart des cas, le compilateur déduit les arguments de type à partir des arguments
Valeur zéro : var zero T ; aucun paramètre de type au niveau d’une méthode

Questions Fréquemment Posées

La leçon « Syntaxe des paramètres de type » est-elle gratuite ?

Oui — le texte complet de « Syntaxe des paramètres de type » 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 « Syntaxe des paramètres de type » ?

Fonctions et types génériques avec [T any] 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 1 sur 4.

Combien de temps prend la leçon « Syntaxe des paramètres de type » ?

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

← Retour à Go Academy