คุณนิยามเมธอดที่มีอาร์กิวเมนต์อย่างไร?

Question

Accepted Answer

**เมธอด (Method)** ใน Ruby นิยามด้วย `def...end` Ruby มีการจัดการอาร์กิวเมนต์ที่ยืดหยุ่นและสื่อความหมายได้ดี ทั้งค่าเริ่มต้น, keyword argument, splat (`*`) สำหรับอาร์กิวเมนต์จำนวนแปรผัน และบล็อก รวมถึงข้อตกลงที่ว่า **expression สุดท้ายเป็นค่าที่คืนกลับโดยปริยาย (implicit return)**

## เมธอดพื้นฐานและ implicit return

```ruby
def add(a, b)
  a + b          # NO `return` needed — the last expression is returned implicitly
end
add(2, 3)         # 5

def greet(name)
  "Hello, #{name}"   # implicitly returned
end
```

เมธอด Ruby **คืน expression สุดท้ายที่ถูกประเมินผล** โดยอัตโนมัติ คุณแทบจะไม่เขียน `return` (ใช้เฉพาะการ return ก่อนเวลาเท่านั้น) นี่คือสไตล์ที่เป็นธรรมชาติ

## อาร์กิวเมนต์แบบค่าเริ่มต้นและ keyword

```ruby
# default arguments
def greet(name, greeting = "Hello")
  "#{greeting}, #{name}"
end
greet("Ann")              # "Hello, Ann"
greet("Ann", "Hi")        # "Hi, Ann"

# KEYWORD arguments (clearer, order-independent) — common in modern Ruby
def create_user(name:, age: 0, role: :user)
  # name is required (no default); age/role optional
end
create_user(name: "Ann", role: :admin)   # pass by keyword — readable
```

**Keyword argument** (`name:`) เป็นสไตล์ Ruby สมัยใหม่ที่เป็นธรรมชาติ มันทำให้การเรียกอธิบายตัวเองได้และไม่ขึ้นกับลำดับ

## Splat argument (จำนวนแปรผัน)

```ruby
def sum(*numbers)        # * collects extra positional args into an array
  numbers.sum
end
sum(1, 2, 3, 4)          # 10

def config(**options)    # ** collects keyword args into a hash
  options[:timeout]
end
config(timeout: 30, retries: 3)
```

`*args` รวบรวมอาร์กิวเมนต์ positional แบบแปรผันเข้าเป็นอาเรย์ ส่วน `**options` รวบรวม keyword argument เข้าเป็นแฮช

## เมธอดที่ลงท้ายด้วย ? และ !

```ruby
def valid?(x)            # ? convention → returns a boolean (predicate method)
  x > 0
end
def process!(data)       # ! convention → modifies in place / is "dangerous"
  data.map!(&:upcase)
end
```

ข้อตกลงในการตั้งชื่อ: เมธอดที่ลงท้ายด้วย **`?`** คืนค่าบูลีน (predicate) และ **`!`** บ่งบอกถึงเวอร์ชันที่ทำลายล้าง/แก้ไขในที่ หรือ "อันตราย"

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

เมธอดเป็นองค์ประกอบพื้นฐานของพฤติกรรมใน Ruby และการเข้าใจการจัดการอาร์กิวเมนต์ที่ยืดหยุ่นและสื่อความหมายได้ดีของ Ruby รวมถึงข้อตกลงต่าง ๆ เป็นความรู้สำคัญในชีวิตประจำวัน

หลายแง่มุมเป็นเอกลักษณ์ของ Ruby และควรรู้ ได้แก่ **implicit return** (เมธอดคืน expression สุดท้ายที่ถูกประเมินผล ดังนั้นแทบไม่เขียน `return` Ruby ที่เป็นธรรมชาติพึ่งพาสิ่งนี้), **keyword argument** (`name:` วิธีสมัยใหม่และเป็นธรรมชาติในการเขียนการเรียกเมธอดที่ชัดเจน อธิบายตัวเองได้ และไม่ขึ้นกับลำดับ) และ **splat argument** (`*args`/`**options` สำหรับอาร์กิวเมนต์จำนวนแปรผัน)

ที่สำคัญเท่าเทียมกันคือ **ข้อตกลงในการตั้งชื่อ** เมธอดที่ลงท้ายด้วย **`?`** เป็น predicate ที่คืนค่าบูลีน (`valid?`, `empty?`) และเมธอดที่ลงท้ายด้วย **`!`** เป็นเวอร์ชันที่ทำลายล้าง/แก้ไขในที่ หรือ "อันตราย" (`map!`, `sort!`) ซึ่งแพร่หลายใน Ruby และ Rails และสื่อสารพฤติกรรมของเมธอดให้เห็นในพริบตา (การรู้ว่า `!` มักหมายถึง "แก้ไขในที่" เป็นสิ่งสำคัญต่อการหลีกเลี่ยงการเปลี่ยนแปลงค่าโดยไม่ตั้งใจ)

การเข้าใจวิธีนิยามเมธอดด้วยอาร์กิวเมนต์ที่ยืดหยุ่นของ Ruby (ค่าเริ่มต้น, keyword, splat) สไตล์ implicit return และข้อตกลงการตั้งชื่อ `?`/`!` เป็นรากฐานสำหรับการเขียนและอ่าน Ruby ที่เป็นธรรมชาติ คุณสมบัติและข้อตกลงเหล่านี้ปรากฏตลอดเวลา และการเข้าใจมัน (โดยเฉพาะ keyword argument สำหรับ API ที่สะอาด และข้อตกลง `?`/`!` สำหรับการเข้าใจพฤติกรรมของเมธอด) เป็นความรู้ที่จำเป็นและใช้บ่อยสำหรับการพัฒนา Ruby ที่มีประสิทธิภาพ