Generics (aka aka a Go 1.18) ba za ka bugi ayyuka da nau'i waɗanda ke aiki tare da nau'ikan da yawa ta hanyar sigina nau'i, daga jihar tsarewa nau'i a lokacin jemini. Suna kawar da zasuwar tsohuwar kwatance-a cikin nau'i na nau'i nau'i ko asarar 'yanci tare da 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] yana ayyana nau'i parameter T tare da ƙunshi (wane nau'i ake ba da izini). Compilar yana yanke hankali T daga hujjoji — aiki ɗaya yana aiki don nau'ikan da yawa, cikakke mai aminci nau'i.
// 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.
ƙunshi yana ayyana wane ayyuka ake ba da izini a kan nau'i parameter (~ nace nace yana nufin "kowane nau'i wanda asali nau'i shine wannan").
// 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.
Generics sun kasua babbar, a miso-biso ƙara zuwa Go (1.18) waɗanda aka warware ga ainihi mai zafi: a gida, rubuta maida-amfani kodwa don nau'ikan da yawa ya tilasta ka ko ko ɗaya: mai karya kod ìsé nau'i (jama'a, wuyar jiya) ko amfani interface{} (asarar 'yanci nau'i a lokacin jemini da neman yin aiki a lokacin jemini).
Generics ba za ka bugi ayyuka da gida masu aminci nau'i da maida-amfani (akwati, abubuwan jimla na taimakon kamar Map/Filter/Reduce) kansu, tare da compilar da ke tilasta inganci da kuma tilasta nau'i.
Ganin nau'i sigina, ƙunshi (gida any, comparable, da haɗe/ ~ syntax), da nau'ikan generiki ba da sa ya zama mahimmanci kamar yadda jiya ya ɗaukar su.
Mahimmanci a kaidai shine Go tunani cewa generics sune kayan aiki don ainihin maida-amfani, ba tsari — amfani amfani da yawa a kansu yana aiki ga ido go fadi.
Wa'ato na gida, a yau-yau magana ana yi game da shi ya nuna iko tare da Go na musamman-musamman.