Go Academy · Leçon

Structures de données génériques

Construire une Stack et un Set génériques

Structures de données génériques est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Pourquoi utiliser des structures de données génériques ?

Avant l'arrivée des génériques, les développeurs Go utilisaient des tranches d'interface{} (avec une perte de sûreté du typage) ou généraient du code pour chaque type. Les génériques permettent de créer des conteneurs réutilisables et sûrs du point de vue du typage.

Pile générique

Une pile sûre du point de vue du typage utilisant un type générique :

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 z T; return z, false }
    n := len(s.items)-1; v := s.items[n]; s.items = s.items[:n]; return v, true
}
func (s *Stack[T]) Len() int { return len(s.items) }

File générique

Une file FIFO reposant sur une tranche :

type Queue[T any] struct{ items []T }
func (q *Queue[T]) Enqueue(v T)     { q.items = append(q.items, v) }
func (q *Queue[T]) Dequeue() (T, bool) {
    if len(q.items)==0 { var z T; return z, false }
    v := q.items[0]; q.items = q.items[1:]; return v, true
}

Ensemble générique

Un ensemble reposant sur une table associative — le type de clé doit être comparable :

type Set[T comparable] struct{ m map[T]struct{} }
func NewSet[T comparable]() *Set[T] { return &Set[T]{m: make(map[T]struct{})} }
func (s *Set[T]) Add(v T)          { s.m[v] = struct{}{} }
func (s *Set[T]) Has(v T) bool     { _, ok := s.m[v]; return ok }
func (s *Set[T]) Delete(v T)       { delete(s.m, v) }

Auxiliaire générique Map

Un Map fonctionnel et sûr du point de vue du typage sur des tranches :

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

Filter générique

Renvoyez une nouvelle tranche contenant uniquement les éléments qui satisfont un prédicat :

func Filter[T any](s []T, predicate func(T) bool) []T {
    var out []T
    for _, v := range s {
        if predicate(v) { out = append(out, v) }
    }
    return out
}

Reduce générique

Réduisez une tranche à une seule valeur :

func Reduce[T, U any](s []T, init U, f func(U, T) U) U {
    acc := init
    for _, v := range s { acc = f(acc, v) }
    return acc
}

OrderedMap

Une table associative ordonnée qui conserve l'ordre d'insertion — utile pour la sérialisation JSON avec un ordre stable des clés :

type OrderedMap[K comparable, V any] struct {
    keys []K
    vals map[K]V
}

Liste chaînée générique

Une liste doublement chaînée dont les éléments sont sûrs du point de vue du typage :

type Node[T any] struct{ Val T; Next, Prev *Node[T] }
type List[T any] struct{ head, tail *Node[T]; len int }

Limitations

Les types génériques ne peuvent pas utiliser de commutateurs de type sur T. Les méthodes des types génériques ne peuvent pas introduire de nouveaux paramètres de type. Vous ne pouvez pas spécialiser un type générique pour un T spécifique (il n'existe pas de spécialisation de modèles).

Performances

L'instanciation des génériques dans Go s'effectue au moyen de « formes GC » : les types ayant la même disposition mémoire partagent une implémentation. Cela évite la génération de code excessif tout en conservant des performances proches de celles des implémentations concrètes.

Quand ne pas utiliser les génériques

Évitez les génériques dans les cas simples où une interface suffit ou lorsque vous n'avez qu'un ou deux types concrets : la complexité ajoutée l'emporte sur le bénéfice.

Vérification rapide

Pourquoi un ensemble générique nécessite-t-il la contrainte comparable sur son paramètre de type ?

Récapitulatif : structures de données génériques

Points clés :

Pile, file et ensemble — sûrs du point de vue du typage grâce aux génériques
Auxiliaires fonctionnels : Map, Filter et Reduce sur []T
Set[T comparable] pour les ensembles reposant sur des tables associatives
Aucun paramètre de type au niveau des méthodes ; aucune spécialisation de modèles

Questions Fréquemment Posées

La leçon « Structures de données génériques » est-elle gratuite ?

Oui — le texte complet de « Structures de données génériques » 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 « Structures de données génériques » ?

Construire une Stack et un Set génériques 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 3 sur 4.

Combien de temps prend la leçon « Structures de données génériques » ?

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