अरे आणि स्लाइसमध्ये काय फरक आहे?

Question

Accepted Answer

**अरे** चे निश्चित आकार आहे जो त्याच्या प्रकारचा भाग आहे; **स्लाइस** हा अंतर्निहित अरेचा लचकदार, गतिशील दृश्य आहे. व्यवहारात आप जवळजवळ नेहमी **स्लाइस** वापरता — अरे दैनंदिन Go मध्ये दुर्लभ आहेत.

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

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

अरे आकार संकलन वेळी निश्चित आहे आणि त्याच्या प्रकारचा भाग आहे (`[5]int` ≠ `[3]int`). अरे **मूल्य प्रकार** देखील आहेत — एक नियुक्त करणे किंवा पास करणे संपूर्ण अरे कॉपी करते. ही कठोरता असे आहे कि ते सरळ वापरले जातात.

## स्लाइस — गतिशील आणि लचकदार

```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)
```

स्लाइसचा निश्चित आकार नाही — आप `append` सह त्याला वाढवता. हे वापरायचे गतिशील क्रम आहे.

## स्लाइस अंतर्गत कसे काम करतात

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

## स्लाइसिंग दृश्य तयार करते (सामायिक समर्थन अरे — एक जाळा)

```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]!
```

स्लाइसिंग (`s[low:high]`) कॉपी करत नाही — हे नवीन स्लाइस हेडर तयार करते जो **समान** अंतर्निहित अरेकडे निर्देश करते. एक सुधारण दुसऱ्यावर परिणाम करू शकते — सूक्ष्म बगचा सामान्य स्रोत. स्वतंत्र कॉपीसाठी `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)
```

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

स्लाइस हे Go च्या सर्वाधिक वापरलेल्या आणि सर्वाधिक गैरसमज वैशिष्ट्यांपैकी एक आहे.

हे समजून घेणे की अरे निश्चित आकार मूल्य प्रकार आहेत (सरळ वापरले जाणे दुर्लभ) तर **स्लाइस** समर्थन अरेचे लचकदार, संदर्भ जसे दृश्य आहेत (दैनंदिन साधन) हे मूलभूत आहे.

गंभीरपणे, **सामायिक समर्थन अरे वर्तन** जाणून घेणे — की स्लाइसिंग दृश्य तयार करते, कॉपी नाही, म्हणून सुधार इतर स्लाइसवर परिणाम करू शकते, आणि `append` पुनः वाटप करू शकते किंवा नाही — सूक्ष्म, डिबग करणे कठीण असलेल्या उपनाम बगच्या वर्गापासून प्रतिबंधित करते जे अनुभवी विकसकदेखील पकडतात.

स्लाइस आयुष्य (len vs cap, append, copy, सामायिक जाळे) मास्टर करणे आवश्यक दैनंदिन Go ज्ञान आहे आणि वारंवार मुलाखत विषय आहे, कारण जवळजवळ सर्व संग्रह कार्य त्यांचा वापर करतात.