Kokia yra skirtumas tarp masyvų ir griausčių?

Question

Accepted Answer

**Masyvas** turi fiksuotą dydį, kuris yra jo tipo dalis; **griausčius** yra lankstus, dinaminis pagrindinės masyvą vaizas. Praktikoje beveik visada naudojate **griausčius** — masyvai yra reti kasdieniniame Go.

## Masyvai — fiksuotas dydis

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

Masyvų dydis yra nustatytas kompiliavimo metu ir yra jo tipo dalis (`[5]int` ≠ `[3]int`). Masyvai taip pat yra **vertės tipai** — priskyrimas arba vieno perdavimas kopijuoja visą masyvą. Ši tvirta struktura yra dėl ko jie retai naudojami tiesiogiai.

## Griausčiai — dinamiški ir lankstūs

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

Griausčius neturi fiksuoto dydžio — jūs jį didinate su `append`. Tai yra dinamiška seka, kurią reikėtų naudoti.

## Kaip griausčiai veikia viduje

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

## Pjaustymas sukuria vaizdą (bendras pagrindinis masyvas — spastai)

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

Pjaustymas (`s[low:high]`) nekopijuoja — jis sukuria naują griauščio antraštę, nukreiptą į **tą patį** pagrindinį masyvą. Vieno pakeitimas gali turėti įtakos kitam — dažnas subtilių klaidų šaltinis. Naudokite `copy()` dėl nepriklausomos kopijos.

## append perskirstymo staigmena

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

## Kodėl tai svarbu

Griausčiai yra viena iš dažniausiai naudojamų ir labiausiai nepainiojamų Go savybių.

Supratimas, kad masyvai yra fiksuoto dydžio vertės tipai (retai naudojami tiesiogiai), o **griausčiai** yra lankstūs, nuorodos panašūs vaizdai į pagrindinį masyvą (kasdieninė priemonė), yra esminė.

Pagrindinė dalykas yra žinoti **bendro pagrindinio masyvo elgesį** — kad pjaustymas sukuria vaizdą, ne kopiją, todėl modifikacijos gali paveikti kitus griausčius, ir kad `append` gali bet ir negali perskirstyti — tai nuo subtilaus, sunkiai sudebuguojamo aliasavimo klaidų klasės, kuri pagauna net patyrusius kūrėjus.

Suprasti griausčius (len vs cap, append, copy, bendrinimo spastus) yra esminės kasdieninės Go žinios ir dažna interviu tema, nes beveik visa kolekcijos darbą naudoja juos.