Arrays और slices के बीच क्या अंतर है?

Question

Accepted Answer

**array** का आकार निश्चित है जो इसके प्रकार का हिस्सा है; **slice** एक अंतर्निहित array का एक लचीला, गतिशील रूप से आकार वाला दृश्य है। व्यवहार में आप लगभग हमेशा **slices** का उपयोग करते हैं — arrays रोज़मर्रा के Go में दुर्लभ हैं।

## Arrays — निश्चित आकार

```go
var arr [5]int               // an array of exactly 5 ints (size is part of the type)
arr[0] = 10
fmt.Println(len(arr))        // 5 — size is fixed forever

// [3]int and [5]int are DIFFERENT types — can't assign one to the other
```

Array का आकार संकलन समय पर निश्चित होता है और इसके प्रकार का हिस्सा है (`[5]int` ≠ `[3]int`)। Arrays **value types** भी हैं — एक को असाइन या पास करना पूरे array को कॉपी करता है। यह कठोरता ही वजह है कि इनका सीधे उपयोग शायद ही किया जाता है।

## Slices — गतिशील और लचीले

```go
s := []int{1, 2, 3}          // a slice (no size in the brackets)
s = append(s, 4)             // grow it — append returns a new slice
fmt.Println(len(s), cap(s))  // length and capacity

nums := make([]int, 0, 10)   // make a slice: length 0, capacity 10 (pre-allocated)
```

Slice का कोई निश्चित आकार नहीं — आप इसे `append` से बढ़ाते हैं। यह जाना-पहचाना गतिशील क्रम है।

## Slices कैसे काम करते हैं अंतर्निहित रूप से

```text
A slice is a small struct: { pointer to underlying array, length, capacity }
  - len = number of elements currently in the slice
  - cap = size of the underlying array from the slice's start
append: if len < cap, reuses the array; if len == cap, allocates a BIGGER array & copies
```

## Slicing एक दृश्य बनाता है (साझा backing array — एक नुकसान)

```go
original := []int{1, 2, 3, 4, 5}
sub := original[1:3]         // [2, 3] — a VIEW into the same backing array
sub[0] = 99                  // ⚠️ also changes original[1] → [1, 99, 3, 4, 5]!
```

Slicing (`s[low:high]`) कॉपी नहीं करता — यह **same** अंतर्निहित array पर इशारा करने वाला एक नया slice header बनाता है। एक को संशोधित करना दूसरे को प्रभावित कर सकता है — सूक्ष्म bugs का एक सामान्य स्रोत। एक स्वतंत्र कॉपी के लिए `copy()` का उपयोग करें।

## append का पुनर्आवंटन आश्चर्य

```go
a := []int{1, 2, 3}
b := append(a, 4)            // may or may not share a's array depending on capacity
// safe pattern: always use the RETURNED slice from append
a = append(a, 4)
```

## यह क्यों महत्वपूर्ण है

Slices Go की सबसे अधिक उपयोग की जाने वाली और सबसे अधिक गलतफहमी की जाने वाली सुविधाओं में से एक हैं।

यह समझना कि arrays निश्चित आकार वाले value types हैं (शायद ही कभी सीधे उपयोग किए जाते हैं) जबकि **slices** एक backing array का लचीला, संदर्भ-जैसा दृश्य हैं (रोज़मर्रा का उपकरण) यह मौलिक है।

मुख्य रूप से, **साझा backing array व्यवहार** को जानना — कि slicing एक दृश्य बनाता है, कॉपी नहीं, इसलिए संशोधन अन्य slices को प्रभावित कर सकते हैं, और कि `append` को पुनः आवंटन हो सकता है या नहीं — सूक्ष्म, hard-to-debug aliasing bugs की एक श्रेणी को रोकता है जो अनुभवी developers को भी पकड़ता है।

Slices में महारत हासिल करना (len vs cap, append, copy, साझा करने के नुकसान) आवश्यक रोज़मर्रा का Go ज्ञान है और एक बार-बार interview विषय है, क्योंकि लगभग सभी collection काम उनका उपयोग करता है।