आप arguments के साथ methods कैसे define करते हैं?

Question

Accepted Answer

Ruby **methods** `def...end` के साथ define किए जाते हैं। Ruby में लचीला, अभिव्यंजक argument handling है — default values, keyword arguments, variable arguments के लिए splat (`*`), और blocks — साथ ही यह परंपरा कि **अंतिम expression implicit return value है**।

## Basic methods and 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 methods स्वचालित रूप से **अंतिम मूल्यांकित expression return करते हैं** — आप शायद ही कभी `return` लिखते हैं (इसका उपयोग केवल early returns के लिए होता है)। यह idiomatic है।

## Default and keyword arguments

```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 arguments** (`name:`) idiomatic modern Ruby हैं — वे calls को self-documenting और order-independent बनाते हैं।

## Splat arguments (variable number)

```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` variable positional arguments को एक array में collect करता है; `**options` keyword arguments को एक hash में collect करता है।

## Methods ending in ? and !

```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
```

Naming conventions: **`?`** में समाप्त होने वाले methods booleans (predicates) return करते हैं, और **`!`** एक destructive/in-place या "dangerous" version को इंगित करता है।

## यह क्यों महत्वपूर्ण है

Methods Ruby में behavior के building blocks हैं, और Ruby के लचीले, अभिव्यंजक argument handling और परंपराओं को समझना महत्वपूर्ण रोज़मर्रा का ज्ञान है।

कई पहलू स्पष्ट रूप से Ruby-विशिष्ट हैं और जानने योग्य हैं: **implicit return** (methods अंतिम मूल्यांकित expression return करते हैं, इसलिए `return` शायद ही कभी लिखा जाता है — idiomatic Ruby इस पर निर्भर करता है), **keyword arguments** (`name:` — साफ़, self-documenting, order-independent method calls लिखने का आधुनिक, idiomatic तरीका), और **splat arguments** (`*args`/`**options` variable संख्या के arguments के लिए)।

समान रूप से महत्वपूर्ण हैं **naming conventions** — **`?`** में समाप्त होने वाले methods booleans return करने वाले predicates हैं (`valid?`, `empty?`), और **`!`** में समाप्त होने वाले methods destructive/in-place या "dangerous" versions हैं (`map!`, `sort!`) — जो Ruby और Rails में व्यापक हैं और एक method के behavior को एक नज़र में बताते हैं (यह जानना कि `!` आमतौर पर "in place modifies" का अर्थ है, अनपेक्षित mutations से बचने के लिए महत्वपूर्ण है)।

Ruby के लचीले arguments (defaults, keywords, splats) के साथ methods को define करना, implicit-return idiom, और `?`/`!` naming conventions को समझना idiomatic Ruby लिखने और पढ़ने के लिए मूलभूत है — ये विशेषताएँ और परंपराएँ लगातार आती हैं, और उन्हें समझना (विशेष रूप से साफ़ APIs के लिए keyword arguments और method behavior को समझने के लिए `?`/`!` परंपराएँ) प्रभावी Ruby विकास के लिए आवश्यक, बार-बार लागू होने वाला ज्ञान है।