Generics (Go 1.18 میں شامل ہوئے) آپ کو ایسے functions اور types لکھنے دیتے ہیں جو type parameters کے ذریعے متعدد types کے ساتھ کام کرتے ہیں، جبکہ compile-time type safety برقرار رکھتے ہیں۔ یہ پرانے trade-off کو ختم کرتے ہیں جہاں یا تو ہر type کے لیے کوڈ duplicate کرنا پڑتا تھا یا interface{} کے ساتھ safety کھونی پڑتی تھی۔
{ ... }
{ ... }
{} { ... }
// 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 ہوتی ہے (کون سے types کی اجازت ہے)۔ compiler arguments سے T کا اندازہ لگاتا ہے — ایک implementation بہت سے types کے لیے کام کرتی ہے، مکمل طور پر 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 پر کون سے operations درست ہیں (~ کا مطلب ہے "کوئی بھی type جس کا underlying type یہ ہو")۔
// 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) جنہوں نے ایک حقیقی تکلیف دہ مسئلہ حل کیا: ان سے پہلے، متعدد types کے لیے reusable کوڈ لکھنا آپ کو مجبور کرتا تھا کہ یا تو اسے ہر type کے لیے duplicate کریں (لمبا، ناقابلِ برقراری) یا interface{} استعمال کریں (compile-time type safety کھو دیں اور runtime assertions کی ضرورت پڑے)۔
Generics آپ کو type-safe، reusable functions اور data structures (containers، Map/Filter/Reduce جیسی collection utilities) ایک بار لکھنے دیتے ہیں، جہاں compiler درستگی کو نافذ کرتا ہے اور types کا اندازہ لگاتا ہے۔
type parameters، constraints (بشمول any، comparable، اور union/~ syntax)، اور generic types کو سمجھنا تیزی سے اہم ہوتا جا رہا ہے کیونکہ ecosystem انہیں اپنا رہا ہے۔
اتنا ہی اہم Go کی سوچ ہے کہ generics حقیقی reuse کے لیے ایک ٹول ہیں، کوئی default نہیں — انہیں حد سے زیادہ استعمال کرنا Go کے سادگی کے فلسفے کے خلاف کام کرتا ہے۔
یہ ایک حالیہ، اکثر زیرِ بحث موضوع ہے جو جدید Go کے ساتھ مہارت کی عکاسی کرتا ہے۔
تفصیلی جوابات کے ساتھ IT انٹرویو سوالات کی ایک لائبریری — جونیئر سے سینئر تک۔
عطیہ دیں