Go Academy · Lezione

Strutture dati generiche

Creare uno Stack e un Set generici

Strutture dati generiche è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Go Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Go Academy include 4 lezioni in totale.

Perché usare strutture dati generiche?

Prima dei generics, gli sviluppatori Go usavano slice di interface{} (perdendo la sicurezza dei tipi) oppure generavano codice specifico per ogni tipo. I generics consentono di creare contenitori riutilizzabili e con sicurezza dei tipi.

Stack generico

Uno stack con sicurezza dei tipi che usa un tipo generico:

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) }

Queue generica

Una coda FIFO basata su una slice:

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
}

Set generico

Un set basato su una map — il tipo delle chiavi deve essere 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) }

Helper Map generico

Una funzione Map funzionale e con sicurezza dei tipi sulle slice:

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 generico

Restituisce una nuova slice che contiene solo gli elementi che soddisfano un predicato:

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 generico

Riduce una slice a un singolo valore:

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

Una mappa ordinata che conserva l'ordine di inserimento, utile per la serializzazione JSON con un ordine stabile delle chiavi:

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

Lista concatenata generica

Una lista doppiamente concatenata con elementi dotati di sicurezza dei tipi:

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

Limitazioni

I tipi generici non possono usare type switch su T. I metodi dei tipi generici non possono introdurre nuovi parametri di tipo. Non è possibile specializzare un tipo generico per uno specifico T (non esiste la specializzazione dei template).

Prestazioni

L'istanziazione dei generics in Go avviene tramite le "GC shapes": i tipi con lo stesso layout di memoria condividono un'unica implementazione. Questo evita la duplicazione del codice mantenendo prestazioni vicine a quelle delle implementazioni concrete.

Quando non usare i generics

Eviti i generics nei casi semplici in cui è sufficiente un'interfaccia o in cui esistono solo uno o due tipi concreti: la complessità aggiuntiva supera il beneficio.

Verifica rapida

Perché un Set generico richiede il vincolo comparable sul proprio parametro di tipo?

Riepilogo: strutture dati generiche

Punti chiave:

Stack, Queue, Set: sicurezza dei tipi grazie ai generics
Helper funzionali: Map, Filter, Reduce su []T
Set[T comparable] per i set basati su map
Nessun parametro di tipo a livello di metodo; nessuna specializzazione dei template

Domande Frequenti

La lezione «Strutture dati generiche» è gratuita?

Sì — il testo completo di «Strutture dati generiche» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Go Academy, passa a CoddyKit PRO. Il corso Go Academy include 4 lezioni in totale.

Cosa imparerò in «Strutture dati generiche»?

Creare uno Stack e un Set generici Eserciti Go Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Go Academy?

Non è richiesta alcuna esperienza precedente. Go Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Strutture dati generiche»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Go Academy?

Sì. Ogni lezione Go Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Go Academy