arrays र slices बीचको भिन्नता के हो?

Question

Accepted Answer

एक **array** को निश्चित आकार छ जो यसको type को भाग हो; एक **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 को आकार compile समय मा निश्चित हुन्छ र यसको type को भाग हो (`[5]int` ≠ `[3]int`)। Arrays पनि **value types** हुन् — एक assign गर्दा वा pass गर्दा पूरो array को copy हुन्छ। यो कठोरता नै कारण हो कि तिनहरु सीधै दुर्लभ छन्।

## 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` को साथ बढाउनु हुन्छ। यो गतिशील sequence को पहिलो पसन्द हो।

## Slices कसरी काम गर्छन् hood अन्तर्गत

```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]`) ले copy गर्दैन — यो नयाँ slice header बनाउँछ जो **एक नै** अन्तर्निहित array मा pointing गर्छ। एकलाई परिवर्तन गर्दा अर्कोलाई असर गर्न सक्छ — यो सूक्ष्म bugs को सामान्य स्रोत हो। स्वतन्त्र copy को लागि `copy()` प्रयोग गर्नुहोस्।

## append को reallocation आश्चर्य

```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** लचकदार, reference-जस्तो दृश्य हुन् अन्तर्निहित array मा (रोजमर्रा को उपकरण) यो मौलिक छ।

महत्त्वपूर्ण रूपमा, **साझा-backing-array व्यवहार** जान्नु — कि slicing ले दृश्य बनाउँछ, copy छैन, त्यसैले परिवर्तन अन्य slices लाई असर गर्न सक्छ, र `append` ले reallocate गर्न सक्छ वा नगर्न सक्छ — यो subtle, hard-to-debug aliasing bugs को एक वर्ग रोक्छ जो अनुभवी developers लाई पनि पकड्छ।

Slices मा निपुण हुनु (len vs cap, append, copy, sharing gotchas) आवश्यक रोजमर्रा Go ज्ञान हो र बारम्बार साक्षात्कार विषय हो, किनकि लगभग सबै collection काम तिनहरु प्रयोग गर्छन्।