arrays ਅਤੇ slices ਵਿਚਕਾਰ ਕੀ ਫਰਕ ਹੈ?

Question

IT Interview Practice · Accepted Answer

ਇੱਕ **array** ਦਾ ਇੱਕ ਨਿਸ਼ਚਿਤ ਆਕਾਰ ਹੁੰਦਾ ਹੈ ਜੋ ਇਸਦੀ type ਦਾ ਹਿੱਸਾ ਹੈ; ਇੱਕ **slice** ਇੱਕ ਲਚਕਦਾਰ, ਗਤੀਸ਼ੀਲ ਅਕਾਰ ਵਾਲਾ view ਹੈ ਜੋ ਇੱਕ ਅਧੀਨ 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 time ਉੱਤੇ ਨਿਸ਼ਚਿਤ ਹੋਵੇ ਅਤੇ ਇਸਦੀ 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` ਨਾਲ ਵਧਾਉਂਦੇ ਹੋ। ਇਹ ਗੋ-ਟੂ dynamic 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 ਇੱਕ 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 ਬਣਾਉਂਦਾ ਹੈ ਜੋ **ਇੱਕੋ** ਅਧੀਨ array ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦਾ ਹੈ। ਇੱਕ ਨੂੰ modify ਕਰਨਾ ਦੂਜੇ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰ ਸਕਦਾ ਹੈ — ਸੂਖਮ 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** ਇੱਕ backing array ਵਿੱਚ ਲਚਕਦਾਰ, reference-ਵਰਗੇ views ਹਨ (ਰੋਜ਼ਮਰ੍ਹਾ ਦਾ tool) ਬੁਨਿਆਦੀ ਹੈ।

ਮਹੱਤਵਪੂਰਣ ਤੌਰ ਉੱਤੇ, **shared-backing-array behavior** ਨੂੰ ਜਾਣਨਾ — ਕਿ slicing ਇੱਕ view ਬਣਾਉਂਦਾ ਹੈ, ਇੱਕ copy ਨਹੀਂ, ਇਸ ਲਈ modifications ਹੋਰ slices ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰ ਸਕਦੇ ਹਨ, ਅਤੇ `append` ਹੋ ਸਕਦਾ ਹੈ ਜਾਂ ਨਹੀਂ reallocate ਕਰ ਸਕਦਾ — ਸਮਖੌਤੀ bugs ਦੀ ਇੱਕ ਕਲਾਸ ਨੂੰ ਰੋਕਦਾ ਹੈ ਜੋ debug ਕਰਨਾ ਮੁਸ਼ਕਲ ਹੁੰਦਾ ਹੈ ਜੋ ਭਾਵੇਂ ਅਨੁਭਵੀ developers ਨੂੰ ਵੀ ਫੜੇ।

Slices ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕਰਨਾ (len vs cap, append, copy, sharing gotchas) ਲਾਜ਼ਮੀ ਰੋਜ਼ਮਰ੍ਹਾ Go ਗਿਆਨ ਹੈ ਅਤੇ ਇੱਕ ਵਾਰ-ਵਾਰ ਆਉਣ ਵਾਲਾ interview topic ਹੈ, ਕਿਉਂਕਿ ਲਗਭਗ ਸਾਰਾ collection ਕੰਮ ਉਹਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।

Arrays — ਨਿਸ਼ਚਿਤ ਆਕਾਰ

Slices — ਗਤੀਸ਼ੀਲ ਅਤੇ ਲਚਕਦਾਰ

Slices hood ਦੇ ਅਧੀਨ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ

Slicing ਇੱਕ view ਬਣਾਉਂਦਾ ਹੈ (shared backing array — ਇੱਕ gotcha)

append ਦਾ reallocation ਸਮਝ

ਇਹ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ

ਸੰਬੰਧਿਤ ਸਵਾਲ