Kuna tofauti gani kati ya arrays na slices?

Question

Accepted Answer

**Array** ina ukubwa usiobadilika ambao ni sehemu ya aina yake; **slice** ni mtazamo unaonyumbulika, wenye ukubwa unaobadilika kuelekea array iliyo chini yake. Kivitendo karibu kila mara unatumia **slices** — arrays ni nadra katika Go ya kila siku.

## Arrays — ukubwa usiobadilika

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

Ukubwa wa array umewekwa wakati wa compile na ni sehemu ya aina yake (`[5]int` ≠ `[3]int`). Arrays pia ni **aina za thamani** — kuipangia au kuipitisha hunakili array nzima. Ugumu huu ndiyo sababu hutumika moja kwa moja mara chache.

## Slices — yenye nguvu na inayonyumbulika

```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 haina ukubwa usiobadilika — unaiongeza kwa `append`. Ndiyo mfuatano unaobadilika unaopendelewa zaidi.

## Jinsi slices zinavyofanya kazi ndani kabisa

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

## Ku-slice huunda mtazamo (array iliyoshirikiwa — tatizo la kawaida)

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

Ku-slice (`s[low:high]`) hakunakili — huunda kichwa kipya cha slice kinachoelekeza kwenye array ile **ile** iliyo chini. Kubadilisha moja kunaweza kuathiri nyingine — chanzo cha kawaida cha makosa ya hila. Tumia `copy()` kupata nakala huru.

## Mshangao wa kuhamisha kumbukumbu wa 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)
```

## Kwa nini ni muhimu

Slices ni mojawapo ya vipengele vinavyotumika zaidi na vinavyoelewekwa vibaya zaidi vya Go.

Kuelewa kwamba arrays ni aina za thamani zenye ukubwa usiobadilika (zinazotumika moja kwa moja mara chache) huku **slices** zikiwa mitazamo inayonyumbulika, kama-rejea kuelekea array iliyo chini (kifaa cha kila siku) ni msingi.

Muhimu zaidi, kujua **tabia ya array iliyoshirikiwa** — kwamba ku-slice huunda mtazamo, si nakala, hivyo mabadiliko yanaweza kuathiri slices nyingine, na kwamba `append` inaweza au isihamishe kumbukumbu — huzuia kundi la makosa ya hila, magumu kutatua ya kushirikiana yanayowapata hata wasanidi wenye uzoefu.

Kubobea slices (len dhidi ya cap, append, copy, matatizo ya kushirikiana) ni maarifa muhimu ya Go ya kila siku na mada ya mara kwa mara ya mahojiano, kwani karibu kazi zote za makusanyo huzitumia.