Go Academy · Les

Generieke datastructuren

Een generieke Stack en Set bouwen

Les 3 van 414 stappen

Generieke datastructuren is een gratis Go Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Go Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Go Academy bevat in totaal 4 lessen.

Waarom generieke gegevensstructuren?

Voor generieke typen gebruikten Go-ontwikkelaars slices van interface{} (waardoor typeveiligheid verloren ging) of genereerden ze code voor elk type. Generieke typen maken typeveilige, herbruikbare containers mogelijk.

Generieke stapel

Een typeveilige stapel met een generiek 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 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) }

Generieke wachtrij

Een FIFO-wachtrij die op een slice is gebaseerd:

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
}

Generieke verzameling

Een verzameling die op een map is gebaseerd — het sleuteltype moet vergelijkbaar zijn:

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

Generieke Map-hulpfunctie

Een typeveilige functionele Map voor slices:

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
}

Generiek Filter

Retourneer een nieuwe slice met alleen elementen die aan een predicaat voldoen:

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
}

Generiek Reduce

Vouw een slice samen tot één waarde:

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

Een geordende map die de invoegvolgorde behoudt — nuttig voor JSON-serialisatie met een stabiele sleutelvolgorde:

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

Generieke gekoppelde lijst

Een dubbel gekoppelde lijst met typeveilige elementen:

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

Beperkingen

Generieke typen kunnen geen typeswitch op T gebruiken. Methoden op generieke typen kunnen geen nieuwe typeparameters introduceren. Je kunt een generiek type niet specialiseren voor een specifieke T (geen specialisatie van sjablonen).

Prestaties

Generieke instantiatie in Go gebeurt via "GC-vormen": typen met dezelfde geheugenindeling delen één implementatie. Zo wordt codegroei voorkomen en blijven de prestaties dicht bij die van concrete implementaties.

Wanneer je geen generieke typen gebruikt

Vermijd generieke typen voor eenvoudige gevallen waarin een interface volstaat, of wanneer je maar één of twee concrete typen hebt — de extra complexiteit weegt dan niet op tegen het voordeel.

Snelle controle

Waarom vereist een generieke verzameling de beperking comparable voor zijn typeparameter?

Beantwoord dit in de interactieve les

Samenvatting: generieke gegevensstructuren

Belangrijkste punten:

Stapel, wachtrij en verzameling — typeveilig met generieke typen
Functionele hulpfuncties: Map, Filter en Reduce voor []T
Set[T comparable] voor verzamelingen die op een map zijn gebaseerd
Geen typeparameters op methoden; geen specialisatie van sjablonen

Gratis beginnen

Leer Go met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 51
Lessen: 203

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Generieke datastructuren” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Go Academy, waaronder “Generieke datastructuren”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Go Academy bevat in totaal 4 lessen.

Wat leer ik in “Generieke datastructuren”?

Een generieke Stack en Set bouwen Je oefent met Go Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Go Academy te beginnen?

Ervaring vooraf is niet nodig. Go Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Generieke datastructuren”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Go Academy?

Ja. Elke les over Go Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Go Academy