Generics (Go 1.18 में जोड़े गए) आपको फ़ंक्शन और प्रकार लिखने देते हैं जो कई प्रकार के साथ type parameters के माध्यम से काम करते हैं, जबकि compile-time type safety बनाए रखते हैं। वे प्रति-प्रकार कोड को duplicate करने या 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] एक type parameter T को एक constraint के साथ घोषित करता है (कौन से प्रकार अनुमत हैं)। Compiler arguments से T का अनुमान लगाता है — एक कार्यान्वयन कई प्रकार के लिए काम करता है, पूरी तरह type-safe।
// 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.
Constraints परिभाषित करते हैं कि type parameter पर कौन से ऑपरेशन वैध हैं (~ का अर्थ है "कोई भी प्रकार जिसका अंतर्निहित प्रकार यह है")।
// 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 Go (1.18) में एक बड़ा, लंबे समय से प्रतीक्षित addition था जिसने एक वास्तविक दर्द बिंदु को हल किया: इससे पहले, कई प्रकार के लिए पुनः प्रयोग योग्य कोड लिखना आपको दो विकल्पों में से एक पर मजबूर करता था — प्रति-प्रकार कोड को duplicate करें (verbose, असंभव रखरखाव) या interface{} का उपयोग करें (compile-time type safety को खोने और runtime assertions की आवश्यकता से बचें)।
Generics आपको type-safe, पुनः प्रयोग योग्य फ़ंक्शन और डेटा संरचनाएं (कंटेनर, संग्रह उपयोगिताएं जैसे Map/Filter/Reduce) एक बार लिखने देते हैं, compiler correctness को लागू करते हुए और प्रकार का अनुमान लगाते हुए।
Type parameters, constraints (including any, comparable, और union/~ syntax), और generic प्रकारों को समझना जैसे-जैसे ecosystem उन्हें अपनाता है वैसे-वैसे अधिक महत्वपूर्ण हो जाता है।
समान रूप से महत्वपूर्ण Go दृष्टिकोण है कि generics genuine reuse के लिए एक tool हैं, default नहीं — उनका अत्यधिक उपयोग Go की simplicity philosophy के विपरीत काम करता है।
यह एक वर्तमान, बार-बार चर्चा का विषय है जो आधुनिक Go के साथ प्रवाह को दर्शाता है।