yield ทำงานอย่างไรในเมธอด?

Question

Accepted Answer

**`yield`** เรียกใช้ **block** ที่ส่งเข้ามาให้เมธอด โดยถ่ายโอนการควบคุมไปยัง block พร้อมส่งค่าให้ได้ตามต้องการ จากนั้นกลับมาทำงานเมธอดต่อ นี่คือวิธีที่เมธอดเรียกใช้ block ที่ได้รับมา และเป็นกลไกเบื้องหลังการวนซ้ำ (iteration) ของ Ruby รวมถึงรูปแบบอันสง่างามอีกมากมาย

## yield พื้นฐาน — เรียกใช้ block ที่ได้รับมา

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

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

เมื่อเมธอดเรียก `yield` มันจะรัน block ที่ส่งเข้ามา (ใน `{ }` หรือ `do...end`) เมธอดเป็นตัวควบคุมว่า *เมื่อใด* (และกี่ครั้ง) ที่ block จะถูกรัน

## yield พร้อมอาร์กิวเมนต์ — ส่งค่าให้ 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)` ส่งค่าไปยังพารามิเตอร์ของ block (`|key, value|`) นี่คือวิธีที่เมธอดสำหรับการวนซ้ำส่งสมาชิกแต่ละตัวให้ block

## การสร้างการวนซ้ำด้วย 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!
```

สิ่งนี้แสดงให้เห็นว่าเมธอดสำหรับการวนซ้ำของ Ruby (`each`, `map`, ฯลฯ) ทำงานภายในอย่างไร — พวกมัน `yield` สมาชิกแต่ละตัวให้ block

## block_given? และการจับ 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?` ตรวจสอบว่ามี block ถูกส่งเข้ามาหรือไม่ (เพื่อหลีกเลี่ยง `LocalJumpError`) และ `&block` จับ block เป็นอ็อบเจกต์ Proc ที่คุณสามารถเก็บไว้หรือส่งต่อได้

## ทำไมจึงสำคัญ

การเข้าใจ `yield` เป็นความรู้ Ruby ที่สำคัญ — มันคือกลไกเบื้องหลังวิธีที่เมธอดเรียกใช้ block ซึ่งเป็นรากฐานของการวนซ้ำอันเป็นเอกลักษณ์ของ Ruby และรูปแบบอันสง่างามอีกมากมาย ดังนั้นการเข้าใจมันจึงช่วยให้เห็นภาพว่า Ruby ส่วนใหญ่ทำงานอย่างไร `yield` เรียกใช้ block ที่ส่งให้เมธอด (ถ่ายโอนการควบคุมไปให้ พร้อมส่งค่าได้ตามต้องการ) ซึ่งเป็นวิธีการทำงานภายในของเมธอดสำหรับการวนซ้ำของ Ruby (`each`, `map`, `select`) อย่างแท้จริง — พวกมัน `yield` สมาชิกแต่ละตัวให้ block

การเข้าใจสิ่งนี้ช่วยไขความลึกลับของการวนซ้ำแบบ block ของ Ruby และทำให้คุณสามารถ **เขียนเมธอดของคุณเองที่รับ block ได้** — เป็นความสามารถอันทรงพลังในการสร้าง API ที่สื่อความหมายได้ดี, iterator ที่กำหนดเอง, เมธอดจัดการทรัพยากร (setup/teardown รอบ block) และ DSL

การรู้จัก `yield` (เรียก block, ส่งอาร์กิวเมนต์ให้), `block_given?` (ตรวจสอบอย่างปลอดภัยว่ามี block ถูกส่งเข้ามาหรือไม่ เพื่อหลีกเลี่ยงข้อผิดพลาด) และ `&block` (จับ block เป็น Proc อย่างชัดเจน) เป็นสิ่งสำคัญทั้งสำหรับการเข้าใจวิธีทำงานของเมธอดสำหรับการวนซ้ำและเมธอดที่รับ block ของ Ruby และสำหรับการเขียนเมธอดที่ใช้ block ของคุณเอง

เนื่องจาก block เป็นแกนหลักของ Ruby และ `yield` คือวิธีที่เมธอดใช้มัน การเข้าใจ `yield` จึงทำให้คุณเข้าใจคุณสมบัติที่โดดเด่นที่สุดของ Ruby (block) ได้ลึกซึ้งขึ้น และช่วยให้คุณเขียนเมธอดที่รับ block ได้อย่างสง่างามแบบที่ทำให้ Ruby สื่อความหมายได้ดี — เป็นทักษะที่มีค่าสำหรับการสร้าง API ที่สะอาดและเป็นหัวข้อสัมภาษณ์ที่พบบ่อยซึ่งสะท้อนความเข้าใจว่ากลไก block ของ Ruby ทำงานเบื้องหลังอย่างไรจริง ๆ