Care este diferența dintre receptorii de valoare și receptorii de pointer?

Question

IT Interview Practice · Accepted Answer

Receptorul unei metode (**receiver**) este valoarea pe care aceasta operează, declarată înainte de numele metodei. Poate fi un **receptor de valoare** (operează pe o copie) sau un **receptor de pointer** (operează pe original-ul, poate îl modifica). Alegerea corectă contează atât pentru corectitudine (mutație) cât și pentru performanță.

## Receptor de valoare — operează pe o COPIE

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

Un receptor de valoare primește o copie a structurii, deci modificările nu afectează original-ul — util pentru metode numai-citire, dar o greșeală dacă intenționai să muți.

## Receptor de pointer — operează pe ORIGINAL

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

Un receptor de pointer operează pe structura actuală, deci poate s-o **modifice**. Go preia automat adresa (`c.Increment()` funcționează chiar și pe o valoare).

## Când să folosești care

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

## Regula consistenței

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

Amestecarea receptorilor de valoare și pointer pe un tip cauzează probleme subtile — convenția este să alegi unul (de obicei pointer dacă vreun metod mută) și să îl folosești pentru toate metodele.

## Subtilitate în satisfacerea interfețelor

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

Acesta este o gotcă comună: cu metode cu receptor de pointer, doar tipul pointer satisface interfața.

## De ce contează

Alegerea dintre receptor de valoare și pointer este o decizie fundamentală, frecvent neînțeleasă în Go, care afectează corectitudinea, performanța și satisfacerea interfețelor.

Greșeala cea mai comună este folosirea unui **receptor de valoare când intenționai să muți** — modificarea afectează în tăcere doar o copie, deci schimbarea „nu se menține.

Receptor de valoare — operează pe o COPIE

Receptor de pointer — operează pe ORIGINAL

Când să folosești care

Regula consistenței

Subtilitate în satisfacerea interfețelor

De ce contează

Întrebări conexe