Cum funcționează yield în metode?

Question

IT Interview Practice · Accepted Answer

**`yield`** apelează **blocul** transmis unei metode — transferă controlul către bloc, opțional transmițând valori acestuia, apoi reia metoda. Este modul în care metodele invocă blocurile care le sunt transmise, și mecanismul din spatele iterației Ruby și al multor șabloane elegante.

## Yield de bază — apelează blocul transmis

```ruby
def greet
  puts "before"
  yield                    # calls the block passed to greet
  puts "after"
end

greet { puts "hello" }
# Output: before / hello / after
```

Când o metodă apelează `yield`, execută blocul care i-a fost transmis (în `{ }` sau `do...end`). Metoda controlează *când* (și de câte ori) se execută blocul.

## yield cu argumente — transmite valori blocului

```ruby
def each_pair
  yield("a", 1)          # pass values to the block's parameters
  yield("b", 2)
end

each_pair { |key, value| puts "#{key}: #{value}" }
# Output: a: 1 / b: 2
```

`yield(args)` transmite valori parametrilor blocului (`|key, value|`) — acesta este modul în care metodele de iterație dau fiecare element blocului.

## Implementarea iterației cu yield

```ruby
def my_each(array)
  i = 0
  while i < array.length
    yield(array[i])        # yield each element to the block
    i += 1
  end
end

my_each([1, 2, 3]) { |n| puts n * 2 }   # 2, 4, 6
# this is essentially how Array#each works internally!
```

Aceasta arată cum funcționează intern metodele de iterație ale Ruby (`each`, `map`, etc.) — ele `yield` fiecare element către bloc.

## block_given? și capturarea blocului

```ruby
def maybe_yield
  if block_given?          # check whether a block was passed (avoid an error)
    yield
  else
    "no block"
  end
end

# explicitly capture the block as a parameter (with &)
def run(&block)            # &block captures the block as a Proc object
  block.call               # call it explicitly
end
```

`block_given?` verifică dacă a fost transmis un bloc (evitând o `LocalJumpError`), și `&block` capturează blocul ca obiect Proc pe care îl puteți stoca sau transmite mai departe.

## De ce este important

Înțelegerea `yield` este cunoaștere importantă în Ruby — este mecanismul din spatele invocării blocurilor de către metode, care stă la baza iterației și a multor șabloane elegante ale Ruby, deci stăpânirea ei iluminează cum funcționează de fapt o mare parte din Ruby. `yield` apelează blocul transmis unei metode (transferând controlul către el, opțional transmițând valori), ceea ce este exact modul în care funcționează intern metodele de iterație ale Ruby (`each`, `map`, `select`) — ele `yield` fiecare element către bloc.

Înțelegerea acestui fapt demistifică iterația pe bază de blocuri din Ruby și vă permite **să scrieți propriile metode care acceptă blocuri** — o capacitate puternică pentru crearea de API-uri expresive, iteratori personalizați, metode de gestionare a resurselor (setup/teardown în jurul unui bloc) și DSL-uri.

Cunoașterea `yield` (apelarea blocului, transmiterea argumentelor acestuia), `block_given?` (verificarea sigură dacă a fost transmis un bloc, evitând erorile) și `&block` (capturarea explicită a blocului ca Proc) este importantă atât pentru înțelegerea modului în care funcționează iterația și metodele care acceptă blocuri din Ruby, cât și pentru scrierea propriilor metode pe bază de blocuri.

Deoarece blocurile sunt centrale pentru Ruby și `yield` este modul în care metodele le utilizează, înțelegerea `yield` vă aprofundează stăpânirea caracteristicii celei mai distinctive a Ruby (blocuri) și vă permite să scrieți genul de metode elegante care acceptă blocuri, care fac ca Ruby să fie expresiv — o abilitate valoroasă pentru construirea de API-uri curate și un subiect frecvent în interviuri care reflectă înțelegerea modului în care mecanismul de blocuri al Ruby funcționează de fapt sub capotă.

Yield de bază — apelează blocul transmis

yield cu argumente — transmite valori blocului

Implementarea iterației cu yield

block_given? și capturarea blocului

De ce este important

Întrebări conexe