რა განსხვავებაა value receiver-სა და pointer receiver-ს შორის?

Question

Accepted Answer

მეთოდის **receiver** არის მნიშვნელობა, რომელზეც ის მოქმედებს, დეკლარირებული მეთოდის სახელამდე. ეს შეიძლება იყოს **value receiver** (მოქმედებს ასლზე) ან **pointer receiver** (მოქმედებს ორიგინალზე, შეიძლება მისი შეცვლა). სწორი არჩევა მნიშვნელოვანია სიზუსტის (მუტაცია) და წარმადობის თვალსაზრისით.

## Value receiver — მოქმედებს ასლზე

```go
type Counter struct { count int }

func (c Counter) Increment() {     // VALUE receiver — c is a COPY
    c.count++                       // modifies the copy, NOT the original
}

c := Counter{}
c.Increment()
fmt.Println(c.count)   // 0 — the original is UNCHANGED (the copy was modified)
```

value receiver იღებს struct-ის ასლს, ამიტომ ცვლილებები არ მოქმედებს ორიგინალზე — სასარგებლო მხოლოდ წაკითხვის მეთოდებისთვის, მაგრამ ხარვეზი თუ თქვენ განიზრახეთ შეცვლა.

## Pointer receiver — მოქმედებს ორიგინალზე

```go
func (c *Counter) Increment() {    // POINTER receiver — c points to the original
    c.count++                       // modifies the ACTUAL struct
}

c := Counter{}
c.Increment()          // Go automatically takes &c
fmt.Println(c.count)   // 1 — the original WAS modified
```

pointer receiver მოქმედებს რეალურ struct-ზე, ამიტომ შეიძლება მისი **შეცვლა**. Go ავტომატურად ღებულობს მისამართს (`c.Increment()` მუშაობს მნიშვნელობაზეც).

## რომელი რა დროს გამოვიყენოთ

```text
Use a POINTER receiver when:
  ✓ The method needs to MODIFY the receiver (mutation)
  ✓ The struct is LARGE (avoid copying it on every call — performance)
  ✓ For CONSISTENCY (see below)

Use a VALUE receiver when:
  ✓ The method only READS, the type is small, and you want copy semantics
  ✓ The type is naturally a value (small structs, basic types)
```

## თანმიმდევრობის წესი

```go
// ✅ be consistent — if ANY method needs a pointer receiver, use pointer for ALL
func (c *Counter) Increment() { c.count++ }
func (c *Counter) Value() int { return c.count }   // pointer too, for consistency
```

value receiver და pointer receiver-ის ერთი ტიპზე შერევა იწვევს დახვეწილ პრობლემებს — კონვენცია ერთის არჩევა (ჩვეულებრივ pointer თუ რომელიმე მეთოდი ცვლის) და ყველა მეთოდის জন্য მისი გამოყენება.

## Interface-ის დაკმაყოფილების დახვეწილობა

```go
type Incrementer interface { Increment() }

// if Increment has a POINTER receiver, only *Counter satisfies the interface, not Counter
var i Incrementer = &Counter{}   // ✅ works
var j Incrementer = Counter{}    // ❌ Counter (value) does NOT satisfy it
```

ეს ჩვეულებრივი საფრთხე: pointer-receiver მეთოდებით, მხოლოდ pointer ტიპი აკმაყოფილებს interface-ს.

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

value და pointer receiver-ის არჩევანი არის Go-ს ფუნდამენტური, ხშირად გაუცხო გადაწყვეტილება, რომელიც მოქმედებს სიზუსტეზე, წარმადობაზე და interface-ის დაკმაყოფილებაზე.

ყველაზე გავრცელებული ხარვეზი არის **value receiver-ის გამოყენება როდესაც თქვენ განიზრახეთ შეცვლა** — ცვლილება ჩმულად მოქმედებს მხოლოდ ასლზე, ამიტომ ცვლილება "არ რჩება". Pointer receiver-ი აუცილებელია მუტაციისთვის და რეკომენდირებული დიდი struct-ებისთვის (მძვინთვარი ასლის თავიდან აცილების მიზნით ყოველი გამოძახებისას).

**თანმიმდევრობის წესი** (ერთი receiver ტიპის გამოყენება ტიპის ყველა მეთოდისთვის) თავიდან აგვაცილებს დაბნეულობას, ხოლო **interface-ის დაკმაყოფილების დახვეწილობა** (pointer-receiver მეთოდი ნიშნავს, რომ მხოლოდ pointer ტიპი აკმაყოფილებს interface-ს) კლასიკური საფრთხე, რომელიც იწვევს "does not implement interface" შეცდომებს.

ამათი გაცნობიერება აუცილებელია სწორი, ეფექტური Go-ს დასაწერად და წარმოადგენს ყველაზე გავრცელებულ პრაქტიკულ და ინტერვიუს თემას, რადგან არჩევანს აქვს აშკარა უგულელყოფილი შედეგები.