Bagaimana cara kerja yield dalam metode?

Question

Accepted Answer

**`yield`** memanggil **block** yang diteruskan ke sebuah metode — ia mentransfer kontrol ke block, secara opsional melewatkan nilai ke dalamnya, kemudian melanjutkan metode. Ini adalah cara metode menjalankan block yang diberikan kepada mereka, dan mekanisme di balik iterasi Ruby dan banyak pola yang elegan.

## Dasar yield — panggil block yang diberikan

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

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

Ketika sebuah metode memanggil `yield`, ia menjalankan block yang diteruskan ke dalamnya (dalam `{ }` atau `do...end`). Metode mengontrol *kapan* (dan berapa kali) block berjalan.

## yield dengan argumen — teruskan nilai ke block

```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)` melewatkan nilai ke parameter block (`|key, value|`) — ini adalah cara metode iterasi memberikan setiap elemen ke block.

## Mengimplementasikan iterasi dengan 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!
```

Ini menunjukkan bagaimana metode iterasi Ruby (`each`, `map`, dll.) bekerja secara internal — mereka `yield` setiap elemen ke block.

## block_given? dan menangkap block

```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?` memeriksa apakah sebuah block telah diteruskan (menghindari `LocalJumpError`), dan `&block` menangkap block sebagai objek Proc yang dapat Anda simpan atau teruskan.

## Mengapa ini penting

Memahami `yield` adalah pengetahuan Ruby yang penting — ini adalah mekanisme di balik cara metode menjalankan block, yang mendasari iterasi dan banyak pola yang elegan di Ruby, sehingga memahaminya menerangi bagaimana sebagian besar Ruby bekerja. `yield` memanggil block yang diteruskan ke metode (mentransfer kontrol ke dalamnya, secara opsional melewatkan nilai), yang merupakan tepat bagaimana metode iterasi Ruby (`each`, `map`, `select`) beroperasi secara internal — mereka `yield` setiap elemen ke block.

Memahami ini memperjelas iterasi berbasis block di Ruby dan memungkinkan Anda **menulis metode Anda sendiri yang menerima block** — kemampuan yang kuat untuk membuat API yang ekspresif, iterator khusus, metode manajemen sumber daya (setup/teardown di sekitar block), dan DSL.

Mengetahui `yield` (memanggil block, melewatkan argumen ke dalamnya), `block_given?` (dengan aman memeriksa apakah sebuah block telah diteruskan, menghindari kesalahan), dan `&block` (secara eksplisit menangkap block sebagai Proc) penting untuk memahami bagaimana iterasi dan metode penerima block Ruby bekerja dan untuk menulis metode berbasis block Anda sendiri.

Karena block adalah pusat Ruby dan `yield` adalah cara metode menggunakannya, memahami `yield` memperdalam pemahaman Anda tentang fitur yang paling khas dari Ruby (block) dan memungkinkan Anda menulis jenis metode penerima block yang elegan yang membuat Ruby ekspresif — keterampilan yang berharga untuk membangun API yang bersih dan topik wawancara umum yang mencerminkan pemahaman tentang bagaimana mekanisme block Ruby sebenarnya berfungsi di balik layar.