Generiki (dodani v Go 1.18) vam omogočajo pisanje funkcij in tipov, ki delujejo z več tipi preko parametrov tipa, pri čemer ohranjate varnost tipov ob času prevajanja. Odpravljajo stari kompromis, pri katerem ste morali bodisi podvajati kodo za vsak tip bodisi izgubiti varnost z interface{}.
{ ... }
{ ... }
{} { ... }
// T is a type parameter constrained to be "ordered" (comparable with < >)
func Max[T constraints.Ordered](a, b T) T {
if a > b {
return a
}
return b
}
Max(3, 5) // T inferred as int → 5
Max(2.5, 1.1) // T inferred as float64 → 2.5
Max("a", "b") // T inferred as string → "b"
[T constraints.Ordered] deklarira parameter tipa T z omejitvijo (katere tipe je dovoljeno uporabljati). Prevajalnik sklepa T iz argumentov — ena implementacija deluje za mnogo tipov, popolnoma varno glede tipov.
// a constraint is an interface listing allowed types or required methods
type Number interface {
~int | ~int64 | ~float64 // the | union means "any of these"
}
func Sum[T Number](nums []T) T {
var total T
for _, n := range nums {
total += n // safe — T is constrained to numeric types
}
return total
}
Sum([]int{1, 2, 3}) // 6
Sum([]float64{1.5, 2.5}) // 4.0
// built-in constraints:
any // any type (alias for interface{})
comparable // types usable with == (for map keys, etc.)
// golang.org/x/exp/constraints: Ordered, Integer, Float, etc.
Omejitve definirajo, katere operacije so veljave na parametru tipa (~ pomeni "katerikoli tip, katerega osnovni tip je ta").
// a generic stack that works for any type
type Stack[T any] struct {
items []T
}
func (s *Stack[T]) Push(item T) { s.items = append(s.items, item) }
func (s *Stack[T]) Pop() T {
item := s.items[len(s.items)-1]
s.items = s.items[:len(s.items)-1]
return item
}
intStack := Stack[int]{} // a stack of ints
strStack := Stack[string]{} // a stack of strings — same code
✓ Generic data structures (stacks, trees, sets), utility functions over collections
(Map, Filter, Reduce), type-safe containers
✗ Don't overuse — if interfaces or a concrete type work simply, prefer them.
Go's philosophy still favors simplicity; generics are a tool, not a default.
Generiki so bili večja, dolgo pričakivana dodatek k Go-u (1.18), ki je razrešil pravo težavo: pred njimi je pisanje ponovno uporabljive kode za več tipov pomenilo bodisi podvajanje kode za vsak tip (dolgočasno, težko vzdržljivo) bodisi uporabo interface{} (izguba varnosti tipov ob času prevajanja in potreba po potrditvah tipov med izvajanjem).
Generiki vam omogočajo, da napišete varno glede tipov in ponovno uporabljive funkcije ter podatkovne strukture (vsebniki, komunalne funkcije zbirk kot Map/Filter/Reduce) le enkrat, pri čemer prevajalnik zagotavlja pravilnost in sklepa tipe.
Razumevanje parametrov tipov, omejitev (vključno s any, comparable in sintakso unije/~) ter generičnih tipov je vedno bolj pomembno, saj ekosistem jih sprejema.
Enako pomembno je Go-ovo razmišljanje, da so generiki orodje za pristno ponovno uporabo, ne privzeta nastavka — prekomerna njihova uporaba nasprotuje Go-ovi filozofiji preprostosti.
To je trenutna, pogosto obravnavana tema, ki odraža tekoče znanje sodobnega Go-a.
Knjižnica IT vprašanj za razgovore s podrobnimi odgovori — od začetnika do izkušenega.
Doniraj