Go मध्ये generics कसे काम करतात?

Question

IT Interview Practice · Accepted Answer

**Generics** (Go 1.18 मध्ये जोडलेले) तुम्हाला टाइप पॅरामीटरद्वारे **एकाधिक प्रकारांसह** काम करणारे फंक्शन्स आणि प्रकार लिहिण्याची परवानगी देतात, तर कंपाइल-टाइम टाइप सेफ्टी राखते. ते पुराने व्यापार-ऑफला दूर करतात: प्रत्येक प्रकारासाठी कोड डुप्लिकेट करा किंवा `interface{}` सह सुरक्षितता गमावा.

## समस्या जी generics सोडवतात

```go
// ❌ before generics — either duplicate per type...
func MaxInt(a, b int) int { ... }
func MaxFloat(a, b float64) float64 { ... }   // copy-paste for each type

// ...or use interface{} and lose type safety + need casts/assertions
func Max(a, b interface{}) interface{} { ... }   // unsafe, clunky
```

## एक generic फंक्शन

```go
// 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]` टाइप पॅरामीटर `T` **मर्यादा** (कोणते प्रकार परवानगीद आहेत) सह घोषित करते. कंपाइलर `T` गुणांतर अनुमान लगाता — एक अंमलबजावणी अनेक प्रकारांसाठी कार्य करते, पूर्णपणे टाइप-सुरक्षित.

## टाइप मर्यादा

```go
// 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.
```

मर्यादा परिभाषित करतात की टाइप पॅरामीटरवर कोणसे ऑपरेशन वैध आहेत (`~` म्हणजे "कोणताही प्रकार ज्याचा अंतर्निहित प्रकार हा आहे").

## Generic प्रकार

```go
// 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
```

## कधी वापरायचे (आणि नाही) generics

```text
✓ 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) एक महत्वाचे, दीर्घकाळ प्रतीक्षित जोडणे होते ज्यांनी खरी समस्या सोडवली: आधी, एकाधिक प्रकारांसाठी पुन्हा वापरता येणारा कोड लिहिल्याने तुम्हाला प्रत्येक प्रकारासाठी कोड डुप्लिकेट करायला (`interface{}` सह टाइप सेफ्टी गमवा आणि रनटाइम अभिजात प्रमाणीकरण आवश्यक आहे) किंवा बाध्य केले गेले.

Generics तुम्हाला टाइप-सुरक्षित, पुन्हा वापरता येणारे फंक्शन्स आणि डेटा स्ट्रक्चर्स (कंटेनर्स, कलेक्शन utilities जसे Map/Filter/Reduce) एकदा लिहू देतात, कंपाइलर सुदृढता लागू करून आणि प्रकार अनुमान लगाता.

टाइप पॅरामीटर्स, मर्यादा (ज्यात `any`, `comparable` आणि union/`~` वाक्यरचना समाविष्ट आहे) आणि generic प्रकार समजून घेणे अधिकाधिक महत्वाचे आहे कारण इकोसिस्टम त्यांना अंगीकार करत आहे.

तेवढेच महत्वाचे म्हणजे Go मानसिकता की generics हे **वास्तविक पुन्हा वापराचे साधन आहे, डिफॉल्ट नाही** — त्यांचा जास्त वापर Go च्या सरलतेच्या तत्वज्ञानाविरुद्ध कार्य करते.

हे एक चालू, वारंवार चर्चा होणारा विषय आहे जो आधुनिक Go सह प्रवाह दर्शवते.

समस्या जी generics सोडवतात

एक generic फंक्शन

टाइप मर्यादा

Generic प्रकार

कधी वापरायचे (आणि नाही) generics

हे का महत्वाचे आहे

संबंधित प्रश्न