yield hoạt động thế nào trong method?

Question

Accepted Answer

**`yield`** gọi **block** được truyền vào một method — nó chuyển quyền điều khiển sang block, có thể truyền giá trị cho nó, rồi tiếp tục method. Đó là cách method gọi các block được trao cho chúng, và là cơ chế đằng sau việc lặp của Ruby cùng nhiều pattern thanh lịch.

## yield cơ bản — gọi block được trao

```ruby
def greet
  puts "before"
  yield                    # gọi block được truyền vào greet
  puts "after"
end

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

Khi một method gọi `yield`, nó chạy block được truyền vào nó (trong `{ }` hoặc `do...end`). Method kiểm soát *khi nào* (và bao nhiêu lần) block chạy.

## yield với đối số — truyền giá trị cho block

```ruby
def each_pair
  yield("a", 1)          # truyền giá trị cho tham số của block
  yield("b", 2)
end

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

`yield(args)` truyền giá trị cho tham số của block (`|key, value|`) — đây là cách các method lặp trao mỗi phần tử cho block.

## Triển khai việc lặp với yield

```ruby
def my_each(array)
  i = 0
  while i < array.length
    yield(array[i])        # yield mỗi phần tử cho block
    i += 1
  end
end

my_each([1, 2, 3]) { |n| puts n * 2 }   # 2, 4, 6
# về cơ bản đây là cách Array#each hoạt động bên trong!
```

Điều này cho thấy cách các method lặp của Ruby (`each`, `map`, v.v.) hoạt động bên trong — chúng `yield` mỗi phần tử cho block.

## block_given? và bắt block

```ruby
def maybe_yield
  if block_given?          # kiểm tra xem có block được truyền không (tránh lỗi)
    yield
  else
    "no block"
  end
end

# bắt block một cách tường minh dưới dạng tham số (với &)
def run(&block)            # &block bắt block dưới dạng object Proc
  block.call               # gọi nó một cách tường minh
end
```

`block_given?` kiểm tra xem có block được truyền không (tránh `LocalJumpError`), và `&block` bắt block dưới dạng object Proc bạn có thể lưu hoặc truyền tiếp.

## Tại sao điều này quan trọng

Hiểu `yield` là kiến thức Ruby quan trọng — đó là cơ chế đằng sau cách method gọi block, vốn nền tảng cho việc lặp đặc trưng của Ruby cùng nhiều pattern thanh lịch, nên nắm bắt nó soi sáng cách phần lớn Ruby thực sự hoạt động. `yield` gọi block được truyền vào một method (chuyển quyền điều khiển sang nó, có thể truyền giá trị), vốn chính xác là cách các method lặp của Ruby (`each`, `map`, `select`) hoạt động bên trong — chúng `yield` mỗi phần tử cho block.

Hiểu điều này làm sáng tỏ việc lặp dựa trên block của Ruby và cho phép bạn **viết các method của riêng mình nhận block** — một năng lực mạnh mẽ để tạo các API biểu đạt, iterator tùy chỉnh, các method quản lý tài nguyên (setup/teardown quanh một block), và DSL.

Biết `yield` (gọi block, truyền đối số cho nó), `block_given?` (kiểm tra an toàn xem có block được truyền không, tránh lỗi), và `&block` (bắt block một cách tường minh dưới dạng Proc) là quan trọng cho cả việc hiểu cách các method lặp và nhận-block của Ruby hoạt động lẫn việc viết các method dựa trên block của riêng bạn.

Vì block là trung tâm của Ruby và `yield` là cách method dùng chúng, hiểu `yield` làm sâu sắc thêm sự nắm bắt của bạn về tính năng đặc trưng nhất của Ruby (block) và cho phép bạn viết loại method nhận-block thanh lịch làm cho Ruby giàu biểu đạt — một kỹ năng có giá trị để xây dựng API sạch và là chủ đề phỏng vấn thường gặp phản ánh sự hiểu biết về cách cơ chế block của Ruby thực sự vận hành bên dưới.