Cili është ndryshimi midis marrësve të vlerës dhe marrësve të pointerit?

Question

Accepted Answer

**Marrësi** i një metode është vlera mbi të cilën vepron, i deklaruar para emrit të metodës. Mund të jetë **marrës vlere** (vepron mbi një kopje) ose **marrës pointeri** (vepron mbi origjinalin, mund ta modifikojë). Zgjedhja e saktë ka rëndësi si për korrektësinë (mutacion) ashtu edhe për performancën.

## Marrës vlere — vepron mbi një KOPJE

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

Një marrës vlere merr një kopje të strukturës, kështu që modifikimet nuk ndikojnë në origjinalin — i dobishëm për metodat vetëm-për-lexim, por një bug nëse keni synuar të mutacionizoni.

## Marrës pointeri — vepron mbi ORIGJINALIN

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

Një marrës pointeri vepron mbi strukturën aktuale, kështu që mund ta **modifikojë** atë. Go automatikisht merr adresën (`c.Increment()` funksionon edhe në një vlerë).

## Kur të përdorni cili

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

## Rregulla e konsistencës

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

Përzierja e marrësve të vlerës dhe pointerit në një tip shkakton probleme subtile — konventa është të zgjedhni njërin (zakonisht pointeri nëse ndonjë metodë mutacionon) dhe ta përdorni për të gjitha metodat.

## Nenuanca e kënaqjes së ndërfaqes

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

Kjo është një gotcha e zakonshme: me metoda me marrës pointeri, vetëm tipi pointer plotëson ndërfaqen.

## Pse ka rëndësi

Zgjedhja e marrësit të vlerës kundër pointerit është një vendim themelor dhe shpesh i keqkuptuar në Go që ndikon në korrektësinë, performancën dhe kënaqjen e ndërfaqes.

Bugi më i zakonshëm është përdorimi i **marrësit të vlerës kur keni synuar të mutacionizoni** — modifikimi në heshtje ndikon vetëm në një kopje, kështu që ndryshimi "nuk qëndron". Marrësit e pointerit janë të nevojshëm për mutacion dhe të rekomanduar për struktura të mëdha (për të shmangur kopje të shtrenjta në çdo thirrje).

**Rregulla e konsistencës** (përdorni të njëjtin lloj marrësi në të gjitha metodat e një tipi) shmang ngatërrimin, dhe **nenuanca e kënaqjes së ndërfaqes** (metodat me marrës pointeri nënkuptojnë se vetëm tipi pointer plotëson ndërfaqen) është një gotcha klasike që shkakton gabime "does not implement interface".

Kuptimi i këtyre është thelbësor për të shkruar Go të saktë dhe efikas dhe është ndër temat më të zakonshme praktike dhe interviste, pasi zgjedhja ka pasoja jo të dukshme.