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