ความแตกต่างระหว่างบล็อก, proc และ lambda คืออะไร?

Question

Accepted Answer

เหล่านี้คือสามวิธีที่ Ruby จัดการกับ **กลุ่มโค้ดในฐานะข้อมูล (code as data)** **บล็อก (block)** ถูกส่งไปยังเมธอด (ไม่ใช่ออบเจ็กต์) ส่วน **Proc** และ **lambda** เป็นออบเจ็กต์ที่ห่อหุ้มบล็อก (เรียกใช้ได้ เก็บได้) Proc และ lambda แตกต่างกันเล็กน้อยในเรื่องการตรวจสอบอาร์กิวเมนต์และพฤติกรรมของ `return`

## บล็อก — ถูกส่งไปยังเมธอด (ไม่ใช่ออบเจ็กต์)

```ruby
[1, 2, 3].each { |n| puts n }     # the { } is a block — passed to each
# a block is NOT an object; it's part of the method call, can't be stored in a variable directly
```

บล็อกคือโค้ดที่ส่งไปยังเมธอด (ใน `{ }` หรือ `do...end`) มันไม่ใช่ออบเจ็กต์เดี่ยว ๆ ที่คุณเก็บได้ มันผูกกับการเรียกเมธอด

## Proc และ lambda — บล็อกในฐานะออบเจ็กต์ที่เก็บได้

```ruby
# a Proc — a block turned into an object you can store and call
square = Proc.new { |x| x * x }
square.call(5)        # 25
square.(5)            # 25 (alternate call syntax)

# a lambda — also a callable object (a "stricter" Proc)
double = lambda { |x| x * 2 }
double = ->(x) { x * 2 }   # the -> "stabby lambda" syntax
double.call(5)        # 10
```

Proc และ lambda ห่อหุ้มบล็อกเข้าเป็น **ออบเจ็กต์** ที่คุณกำหนดให้กับตัวแปร ส่งต่อ และเรียกในภายหลังได้ (`.call`) มีประโยชน์สำหรับการเก็บพฤติกรรมที่นำกลับมาใช้ใหม่ได้

## ความแตกต่างหลัก: อาร์กิวเมนต์และ return

```text
1. ARGUMENT CHECKING:
   lambda → STRICT: errors if wrong number of arguments (like a method)
   proc   → LENIENT: ignores extra args, fills missing with nil

2. RETURN behavior:
   lambda → `return` returns from the LAMBDA (like a normal method)
   proc   → `return` returns from the ENCLOSING METHOD (can surprise you!)
```

```ruby
def test_proc
  p = Proc.new { return 10 }
  p.call                       # returns from test_proc ENTIRELY → 10
  return 20                    # never reached!
end

def test_lambda
  l = lambda { return 10 }
  l.call                       # returns from the LAMBDA only → 10
  return 20                    # reached → test_lambda returns 20
end
```

ความแตกต่างที่สำคัญที่สุด: **lambda ทำตัวเหมือนเมธอด** (อาร์กิวเมนต์เข้มงวด `return` ออกจากแค่ lambda) ในขณะที่ **proc ผ่อนปรนกว่า** (เพิกเฉยต่อความไม่ตรงของอาร์กิวเมนต์ และ `return` ออกจากเมธอดที่ครอบมันอยู่ ซึ่งอาจทำให้เกิดพฤติกรรมที่น่าประหลาดใจ) **โดยทั่วไปนิยมใช้ lambda** เพราะพฤติกรรมที่เหมือนเมธอดและคาดเดาได้

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

การเข้าใจบล็อก, proc และ lambda โดยเฉพาะความแตกต่างของมัน เป็นความรู้ Ruby ที่สำคัญซึ่งสะท้อนความเข้าใจที่ลึกซึ้งว่า Ruby จัดการกับ code as data อย่างไร **บล็อก** เป็นที่พบบ่อยที่สุด (ส่งไปยังเมธอดสำหรับการวนซ้ำและ callback คุณสมบัติอันเป็นเอกลักษณ์ของ Ruby) ในขณะที่ **proc และ lambda** เปลี่ยนบล็อกเป็นออบเจ็กต์ที่เก็บได้และนำกลับมาใช้ใหม่ได้ ซึ่งคุณกำหนดให้ตัวแปร ส่งต่อ และเรียกในภายหลังได้ (มีประโยชน์สำหรับการเก็บพฤติกรรม การสร้างรูปแบบเชิงฟังก์ชัน และการส่ง callback เป็นค่า)

**ความแตกต่างหลักระหว่าง proc และ lambda** นั้นละเอียดอ่อนแต่สำคัญและเป็นหัวข้อสัมภาษณ์ที่พบบ่อย: **การตรวจสอบอาร์กิวเมนต์** (lambda เข้มงวดเหมือนเมธอด proc ผ่อนปรน) และโดยเฉพาะ **พฤติกรรมของ `return`** (`return` ของ lambda ออกจากแค่ lambda ในขณะที่ `return` ของ proc ออกจาก*เมธอดที่ครอบมันอยู่* ซึ่งอาจทำให้เกิดพฤติกรรมที่น่าประหลาดใจและดีบักยาก)

การเข้าใจความแตกต่างเหล่านี้ ที่ว่า **lambda ทำตัวเหมือนเมธอด** (เข้มงวด คาดเดาได้ มี return เฉพาะที่) ในขณะที่ **proc ผ่อนปรนกว่าพร้อมความหมายของ return ที่น่าประหลาดใจ** เป็นสิ่งสำคัญต่อการใช้มันอย่างถูกต้อง และต่อคำแนะนำที่พบบ่อยให้ **นิยมใช้ lambda** เพราะพฤติกรรมที่คาดเดาได้และเหมือนเมธอด

ในขณะที่บล็อกเป็น Ruby ในชีวิตประจำวันและ proc/lambda ถูกใช้สำหรับ callback ที่เก็บได้และรูปแบบเชิงฟังก์ชัน การเข้าใจทั้งสามอย่าง (โดยเฉพาะความแตกต่างของ return และอาร์กิวเมนต์ระหว่าง proc กับ lambda) สะท้อนความรู้ Ruby ที่มั่นคง ช่วยให้คุณหลีกเลี่ยงจุดพลาดของ proc-return และเป็นหัวข้อสัมภาษณ์คลาสสิกที่แยกแยะนักพัฒนาที่เข้าใจการจัดการ code as object ของ Ruby อย่างแท้จริง