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 પણ **મૂલ્ય પ્રકાર** છે — એક તફાવત કરવું અથવા પાસ કરવું આખો 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 એક દૃશ્ય બનાવે છે (શેર કરેલ બેકિંગ 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]`) નકલ કરતું નથી — તે **સમાન** અંતર્ગત array તરફ નવું slice હેડર બનાવે છે. એક સુધરણા બીજાને અસર કરી શકે છે — સૂક્ષ્મ ખામીના સામાન્ય સ્ત્રોત. સ્વતંત્ર નકલ માટે `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 નિશ્ચિત-કદ મૂલ્ય પ્રકાર છે (સીધુ ઉપયોગ થાય અાપતો છે) જ્યારે **slices** બેકિંગ array માં લવચક, સંદર્ભ-જેવો દૃશ્ય છે (રોજનદી સાધન) તે મૂળભૂત છે.

ahme રીતે, **શેર કરેલ બેકિંગ array વર્તણુક** જાણવું — કે slicing એક દૃશ્ય બનાવે છે, નકલ નથી, તેથી સુધરણા અન્ય slices ને અસર કરી શકે છે, અને તે `append` પુનર્ફાળણ કરી શકે છે કે નહીં — સૂક્ષ્મ, આવાજ-અમુક aliasing ખામીનો વર્ગ રોકે છે જે અનુભવી વિકાસકર્તાઓને પણ ધરી આપે છે.

Slices માસ્ટર કરવું (len vs cap, append, copy, શેરિંગ ફંદા) આવશ્યક રોજનદી Go જ્ઞાન છે અને વારંવાર interviewing વિષય છે, કારણ કે લગભગ તમામ સંગ્રહ કાર્ય તેનો ઉપયોગ કરે છે.