Hur fungerar yield i metoder?

Question

Accepted Answer

**`yield`** anropar **blocket** som skickats till en metod — det överför kontrollen till blocket, och kan eventuellt skicka värden till det, för att sedan återuppta metoden. Det är hur metoder anropar blocken som ges till dem, och mekanismen bakom Rubys iteration och många eleganta mönster.

## Grundläggande yield — anropa det givna blocket

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

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

När en metod anropar `yield`, kör den blocket som skickades till den (i `{ }` eller `do...end`). Metoden styr *när* (och hur många gånger) blocket körs.

## yield med argument — skicka värden till blocket

```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)` skickar värden till blockets parametrar (`|key, value|`) — det är så iterationsmetoder ger varje element till blocket.

## Implementera iteration med 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!
```

Detta visar hur Rubys iterationsmetoder (`each`, `map`, osv.) fungerar internt — de `yield`:ar varje element till blocket.

## block_given? och att fånga blocket

```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?` kontrollerar om ett block skickades (vilket undviker en `LocalJumpError`), och `&block` fångar blocket som ett Proc-objekt som du kan lagra eller skicka vidare.

## Varför det är viktigt

Att förstå `yield` är viktig Ruby-kunskap — det är mekanismen bakom hur metoder anropar block, vilket utgör grunden för Rubys signaturer iteration och många eleganta mönster, så att förstå det belyser hur mycket av Ruby faktiskt fungerar. `yield` anropar blocket som skickats till en metod (överför kontrollen till det, eventuellt skickande värden), vilket är exakt hur Rubys iterationsmetoder (`each`, `map`, `select`) fungerar internt — de `yield`:ar varje element till blocket.

Att förstå detta demystifierar Rubys block-baserade iteration och låter dig **skriva dina egna metoder som accepterar block** — en kraftfull möjlighet för att skapa uttrycksfulla API:er, anpassade iteratorer, resurshanterings­metoder (setup/teardown omkring ett block) och DSL:er.

Att känna till `yield` (anropande av blocket, skickande av argument till det), `block_given?` (säker kontroll av om ett block skickades, undvikande av fel) och `&block` (explicit fångande av blocket som ett Proc) är viktigt både för att förstå hur Rubys iteration och block-accepterande metoder fungerar och för att skriva dina egna block-baserade metoder.

Eftersom block är centrala för Ruby och `yield` är hur metoder använder dem, fördjupar förståelse av `yield` din uppfattning om Rubys mest utmärkande funktion (block) och gör det möjligt för dig att skriva den typen av eleganta, block-accepterande metoder som gör Ruby uttrycksfull — en värdeful skicklighet för att bygga rena API:er och ett vanligt intervjuämne som återspeglar förståelse för hur Rubys blockmekanism faktiskt fungerar under huven.