Cad an difríochtaí idir arrays agus slices?

Question

IT Interview Practice · Accepted Answer

Tá méid seasta ag **array** atá ina chuid den chineál; is **slice** ná radharc solúbtha, dinimiciúil-mhéid ar array taobhthíos. I gcleachtas, úsáideann tú **slices** i gcónaí — is annamh a bhíonn arrays ann i nGo laethúil.

## Arrays — méid seasta

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

Tá méid an array socraithe ag an am tiomsúcháin agus ina chuid den chineál (`[5]int` ≠ `[3]int`). Is **cineálacha luach** iad arrays freisin — nuair a dhíonn tú nó a sheolann tú ceann, déantar cóip den array ar fad. Seo an chúis go bhfuil siad annamh a úsáid go díreach.

## Slices — dinimiciúil agus solúbtha

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

Nilann méid seasta ar slice — déanann tú a fhás le `append`. Is é seo an seicheamh dinimiciúil is gnách a úsáid.

## Conas a oibríonn slices faoin bhonn

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

## Cruthaíonn slicing radharc (array tacaíochta roinnte — dochar)

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

Ní dhéanann slicing (`s[low:high]`) cóip — cruthaíonn sé ceanntásc slice nua ag pointe ar an **tsame** array taobhthíos. Is féidir athrú ar dhuine a dhéanamh a bheith ina bhealach eile — foinse choitianta fabhtanna foluaineacha. Úsáid `copy()` do chóip neamhspleách.

## Iontas athsannadh 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)
```

## Cén fáth go bhfuil sé tábhachtach

Is iad slices ceann de na gné is mó a úsáidtear agus is mó a bhíonn míshuim air i nGo.

Tuiscint go bhfuil cineálacha luach méid seasta ag arrays (annamh a úsáidtear iad go díreach) cé go bhfuil **slices** ná radhairc solúbtha, cosúil le tagartha, ar array tacaíochta (an uirlis laethúil) bunúsach.

Túsúil, eolas an **ghníomhaíochta array tacaíochta roinnte** — go gcruthaíonn slicing radharc, ní cóip, mar sin is féidir athruithe a bheith ina bhealach ar slices eile, agus go bhféadfaidh nó go bhféadfaidh `append` nach réamhshocrú — cosc a chur ar aicme fabhtanna aliasing foluaineacha, deacair a dhí-bhogadh a bheirionn ar fheidhmeoirí as an ngnáth fiú.

Mastreoir slices (len vs cap, append, copy, na dochair roinnte) is eolas Go laethúil riachtanach agus ábhar agallamh minic é, ós rud é go n-úsáideann beagnach gach obair bailiúcháin iad.

Arrays — méid seasta

Slices — dinimiciúil agus solúbtha

Conas a oibríonn slices faoin bhonn

Cruthaíonn slicing radharc (array tacaíochta roinnte — dochar)

Iontas athsannadh append

Cén fáth go bhfuil sé tábhachtach

Ceisteanna gaolmhara