რა განსხვავებაა მასივებსა და ნაჭუჭებს შორის?

Question

Accepted Answer

**მასივი** აქვს ფიქსირებული ზომა, რომელიც მისი ტიპის ნაწილია; **ნაჭუჭი** არის მოქნილი, დინამიური ხედი მიმდებარე მასივში. პრაქტიკაში თითქმის ყოველთვის იყენებთ **ნაჭუჭებს** — მასივები იშვიათია ყოველდღიური Go-ში.

## მასივები — ფიქსირებული ზომა

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

მასივის ზომა ფიქსირებულია კომპილაციის დროს და მისი ტიპის ნაწილია (`[5]int` ≠ `[3]int`). მასივები ასევე **მნიშვნელობის ტიპები** — ერთის მინიჭება ან გადაცემა მთელი მასივის ასლს ქმნის. ეს სიმკაცრე იმის მიზეზია, რომ მათი პირდაპირი გამოყენება იშვიათია.

## ნაჭუჭები — დინამიური და მოქნილი

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

ნაჭუჭი არ აქვს ფიქსირებული ზომა — თქვენ გაზრდით იგი `append`-ით. ეს არის სასარგებლო დინამიური მიმდევრობა.

## როგორ მუშაობენ ნაჭუჭები შიგნით

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

## დაკვეცა ხედს ქმნის (ზიზღის მასივი — ხაფანგი)

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

დაკვეცა (`s[low:high]`) არ ქმნის ასლს — ის ქმნის ახალ ნაჭუჭის სათავეს, რომელიც ნიშნავს **იგივე** მიმდებარე მასივს. ერთის შეცვლა შეიძლება გავლენა მოახდინოს სხვაზე — მახასიათებელი წყარო დელიკატური ხარვეზებისთვის. გამოიყენეთ `copy()` დამოუკიდებელი ასლისთვის.

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

## რატომ არის ეს მნიშვნელოვანი

ნაჭუჭები არის Go-ს ერთ-ერთი ყველაზე ხშირად გამოყენებული და ყველაზე არასწორად გაგებული მახასიათებელი.

შეგება იმისა, რომ მასივები არის ფიქსირებული ზომის მნიშვნელობის ტიპები (იშვიათად გამოიყენება პირდაპირ), ხოლო **ნაჭუჭები** არის მოქნილი, მითითებას მსგავსი ხედები მიმდებარე მასივში (ყოველდღიური ინსტრუმენტი) არის ფუნდამენტური.

მნიშვნელოვანი აქ არის იმის ცოდნა, რომ **ზიზღის მასივის ქცევა** — რომ დაკვეცა ხედს ქმნის, ასლს კი არა, ასე რომ შეცვლებმა შეიძლება გავლენა მოახდინოს სხვა ნაჭუჭებზე, და რომ `append` შეიძლება ან არ შეიძლება გადაიზომოს — ხელს უშლის დელიკატური, რთული გამართვის aliasing ხარვეზების კლასს, რომელიც დაიჭირა თუნდაც გამოცდილი დეველოპერი.

ნაჭუჭების დაუფლება (len vs cap, append, copy, შეზიარების ხაფანგები) არის აუცილებელი ყოველდღიური Go ცოდნა და ხშირი ინტერვიუს თემა, რადგან თითქმis ყველა კოლექციის სამუშაო მათ იყენებს.