Go Academy · Leçon

Contraintes : comparable et interfaces

Contraintes d’union et type intégré comparable

Contraintes : comparable et interfaces est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

Qu’est-ce qu’une contrainte ?

Une contrainte limite les types pouvant être utilisés comme argument de type. Sans contrainte, le paramètre de type est any (l’interface vide — elle ne prend en charge que l’affectation et la comparaison avec ==).

La contrainte any

any (alias de interface{}) est la contrainte la plus large : tous les types la satisfont. Vous ne pouvez utiliser que les opérations prises en charge par tous les types : l’affectation et le passage à des paramètres d’interface.

func Print[T any](v T) { fmt.Println(v) }

La contrainte comparable

comparable limite le paramètre de type aux types prenant en charge == et !=. Elle est nécessaire pour utiliser le type comme clé de Map ou dans des vérifications d’égalité.

func Contains[T comparable](s []T, v T) bool {
    for _, item := range s {
        if item == v { return true }
    }
    return false
}

Contraintes d’interface

Utilisez une interface comme contrainte pour exiger des méthodes précises. Le paramètre de type doit posséder toutes les méthodes de l’interface.

type Stringer interface { String() string }

func Print[T Stringer](v T) {
    fmt.Println(v.String())
}

Contraintes d’union

Utilisez une union de types avec | pour limiter l’ensemble des types concrets autorisés. Cela permet d’utiliser des opérateurs (comme +) qui ne font partie d’aucune interface.

type Number interface {
    int | int64 | float64
}

func Sum[T Number](s []T) T {
    var total T
    for _, v := range s { total += v }
    return total
}

~T pour les types sous-jacents

Utilisez ~T pour inclure non seulement T, mais aussi tous les types dont T est le type sous-jacent (par exemple, les types personnalisés définis avec type MyInt int).

type Integer interface { ~int | ~int64 }

type MyInt int
// MyInt satisfies Integer because its underlying type is int

golang.org/x/exp/constraints

Le paquet constraints fournit des interfaces de contrainte courantes : Ordered (prend en charge <), Integer, Float, Signed, Unsigned.

import "golang.org/x/exp/constraints"

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

Paquet cmp (Go 1.21)

Go 1.21 a ajouté la contrainte cmp.Ordered ainsi que les fonctions cmp.Compare/cmp.Less dans la bibliothèque standard, remplaçant la dépendance exp/constraints.

import "cmp"
func Min[T cmp.Ordered](a, b T) T { return min(a, b) }

Combinaison de contraintes

Intégrez plusieurs interfaces dans une contrainte pour exiger plusieurs propriétés :

type Printable interface {
    comparable
    fmt.Stringer
}

Inférence des contraintes

Le compilateur déduit les paramètres de type à partir des arguments. Si la contrainte est trop générale (any), des arguments de type explicites peuvent être nécessaires pour guider l'inférence.

Quand utiliser comparable

Utilisez comparable lorsque la fonction générique doit utiliser == sur des valeurs, les stocker comme clés dans des tables associatives ou les utiliser comme éléments de tables associatives ou d'ensembles. Tous les types ne sont pas comparables (les tranches, les tables associatives et les fonctions ne le sont pas).

Vérification rapide

Que signifie le préfixe ~ dans une contrainte d'union telle que ~int ?

Récapitulatif : contraintes

Points clés :

any : la plus large ; comparable : prend en charge == ; interface : exige des méthodes
L'union (int|float64) permet d'utiliser les opérateurs arithmétiques
~T inclut les types nommés dont T est le type sous-jacent
cmp.Ordered (Go 1.21+) pour les contraintes avec <, >, <=, >=

Questions Fréquemment Posées

La leçon « Contraintes : comparable et interfaces » est-elle gratuite ?

Oui — le texte complet de « Contraintes : comparable et interfaces » 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 « Contraintes : comparable et interfaces » ?

Contraintes d’union et type intégré comparable 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 2 sur 4.

Combien de temps prend la leçon « Contraintes : comparable et interfaces » ?

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