Bagaimana yield berfungsi dalam kaedah?

Question

Accepted Answer

**`yield`** memanggil **blok** yang dihantar kepada kaedah — ia memindahkan kawalan kepada blok, secara pilihan menghantar nilai kepadanya, kemudian menyambung semula kaedah. Ia adalah cara kaedah menggunakan blok yang diberikan kepadanya, dan mekanisme di sebalik lelaran Ruby dan banyak corak yang elegan.

## yield asas — panggil blok yang diberikan

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

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

Apabila kaedah memanggil `yield`, ia menjalankan blok yang dihantar kepadanya (dalam `{ }` atau `do...end`). Kaedah mengawal *bila* (dan berapa kali) blok berjalan.

## yield dengan argumen — hantar nilai kepada blok

```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)` menghantar nilai kepada parameter blok (`|key, value|`) — ini adalah cara kaedah lelaran memberikan setiap elemen kepada blok.

## Melaksanakan lelaran 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 kaedah lelaran Ruby (`each`, `map`, dll.) berfungsi secara dalaman — ia `yield` setiap elemen kepada blok.

## block_given? dan menangkap blok

```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 sama ada blok dihantar (mengelakkan `LocalJumpError`), dan `&block` menangkap blok sebagai objek Proc yang boleh anda simpan atau hantar seterusnya.

## Mengapa ia penting

Memahami `yield` adalah pengetahuan Ruby yang penting — ia adalah mekanisme di sebalik cara kaedah menggunakan blok, yang menyokong lelaran tanda tangan Ruby dan banyak corak yang elegan, jadi menguasainya menjelaskan bagaimana sebahagian besar Ruby sebenarnya berfungsi. `yield` memanggil blok yang dihantar kepada kaedah (memindahkan kawalan kepadanya, secara pilihan menghantar nilai), yang merupakan tepatnya bagaimana kaedah lelaran Ruby (`each`, `map`, `select`) beroperasi secara dalaman — ia `yield` setiap elemen kepada blok.

Memahami ini menyahmisterikan lelaran berasaskan blok Ruby dan membolehkan anda **menulis kaedah anda sendiri yang menerima blok** — satu keupayaan berkuasa untuk mencipta API ekspresif, iterator tersuai, kaedah pengurusan sumber (persediaan/pembersihan di sekeliling blok), dan DSL.

Mengetahui `yield` (memanggil blok, menghantar argumen kepadanya), `block_given?` (memeriksa dengan selamat sama ada blok dihantar, mengelakkan ralat), dan `&block` (menangkap blok secara eksplisit sebagai Proc) adalah penting untuk kedua-dua memahami bagaimana lelaran Ruby dan kaedah yang menerima blok berfungsi dan untuk menulis kaedah berasaskan blok anda sendiri.

Memandangkan blok adalah teras kepada Ruby dan `yield` adalah cara kaedah menggunakannya, memahami `yield` mendalamkan pemahaman anda tentang ciri Ruby yang paling tersendiri (blok) dan membolehkan anda menulis kaedah penerima-blok yang elegan yang menjadikan Ruby ekspresif — satu kemahiran berharga untuk membina API yang bersih dan topik temu duga lazim yang mencerminkan pemahaman tentang bagaimana mekanisme blok Ruby sebenarnya berfungsi di sebalik tabir.