Menene bambanci tsakanin arrays da slices?

Question

Accepted Answer

**array** yana da turmi mai tsayawa wanda yake ɓangare na nau'insa; **slice** shine sanyu mai sassauci, na girma-dinamik na array na ƙarƙashin. A aiki, kuwa koyaushe kana amfani da **slices** — arrays ba su da yawa a yau-yau Go.

## Arrays — turmi mai tsayawa

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

Turmin array an ƙarƙata a lokaci na compilation kuma ɓangare ne na nau'insa (`[5]int` ≠ `[3]int`). Arrays kuma su ne **nau'in ƙima** — ba da array ko aika daya yana jiye gaida array. Wannan tsaurawa shi ne dalilin da yasa a ba su amfani kai tsaye.

## Slices — dinamik kuma mai sassauci

```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 ba shi da turmi mai tsayawa — kika kawo shi tare da `append`. Wannan shi ne jerin dinamik na aiki.

## Yadda slices ke aiki karkashin mahimmanci

```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 yana jawo anfani (gaba jiya array — wata damina)

```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]`) ba sa yin jiya — yana jawo sabon shugabanci slice nasan ga **sama** array karkashin. Ƙarewa daya zai iya sa'a jahar — tushen gida na ɓata mara ba su da yawa. Yin amfani da `copy()` don ɓata mara hanci.

## append gida gida damina

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

## Me yasa ya zama mahimmanci

Slices daya daga abubuwan da ake amfani sosai da abubuwan da ba a fahimta sosai a Go.

Fahimci cewa arrays nau'i ƙima na turmi mai tsayawa ne (wanda ba za a amfani kai tsaye ba) yayin da **slices** su ne sanyu mai sassauci, kamar-kamar nasu, a gaba jiya array (kayan aiki na kwanan nan) shine ainihi.

Tabbas, sanin **halayen gaba jiya array ta gida** — cewa slicing yana jawo sanyu, ba jiya, don haka dillallai zasu iya sa'a jahar slices masu danna, kuma cewa `append` zai iya ko ba zai sake ƙarƙata ba — yana kashe ajin ɓata mara ba su da yawa, mara wahala-wahala aliasing bugs waɗanda suka kama ma ƴa kasu-kasu masu kasuwa.

Mastering slices (len vs cap, append, copy, gida damina) ainihi ne kayan aiki na Go kwanan nan kuma jiya mara kowa a lokaci na tattalin, tun kusan duk aikin tarin yana amfani dasu.