arrays اور slices میں کیا فرق ہے؟

Question

Accepted Answer

ایک **array** کی ایک fixed size ہے جو اس کی type کا حصہ ہے؛ ایک **slice** ایک لچکدار، dynamically-sized view ہے جو ایک underlying array میں ہے۔ عملی طور پر آپ تقریباً ہمیشہ **slices** استعمال کرتے ہیں — arrays روز مرہ کے Go میں نایاب ہیں۔

## Arrays — fixed size

```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 کی size compile time پر fixed ہے اور یہ اس کی type کا حصہ ہے (`[5]int` ≠ `[3]int`)۔ Arrays **value types** بھی ہیں — ایک کو assign یا pass کرنے سے پوری array copy ہوتی ہے۔ یہ سختی یہی وجہ ہے کہ وہ براہ راست استعمال میں نایاب ہیں۔

## Slices — dynamic اور flexible

```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 کی کوئی fixed size نہیں ہے — آپ اسے `append` کے ساتھ بڑھاتے ہیں۔ یہ go-to dynamic sequence ہے۔

## Slices کیسے کام کرتے ہیں under the 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 ایک view بناتا ہے (shared backing array — ایک gotcha)

```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 بناتا ہے جو **same** underlying array کی طرف اشارہ کرتا ہے۔ ایک کو modify کرنے سے دوسرا متاثر ہو سکتا ہے — یہ subtle bugs کا ایک عام ذریعہ ہے۔ ایک independent copy کے لیے `copy()` استعمال کریں۔

## append کا reallocation surprise

```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 کی سب سے زیادہ استعمال اور سب سے زیادہ غلط فہمی والی features میں سے ایک ہیں۔

یہ سمجھنا کہ arrays fixed-size value types ہیں (براہ راست استعمال میں نایاب) جبکہ **slices** لچکدار، reference جیسے views ہیں ایک backing array میں (روز مرہ کا tool) بنیادی ہے۔

evils طور پر، **shared-backing-array behavior** کو جاننا — کہ slicing ایک view بناتا ہے، copy نہیں، اس لیے modifications دوسرے slices کو متاثر کر سکتے ہیں، اور یہ کہ `append` ہو سکتا ہے reallocate کریں یا نہ کریں — subtle، hard-to-debug aliasing bugs کی ایک class کو روکتا ہے جو experienced developers کو بھی پکڑتے ہیں۔

Slices میں تسلط حاصل کرنا (len vs cap, append, copy, sharing gotchas) روز مرہ Go علم میں ضروری ہے اور ایک بار بار آنے والا interview topic ہے، کیونکہ تقریباً تمام collection کام انہیں استعمال کرتے ہیں۔