तुम्ही वितर्कांसह पद्धती कशी व्यक्त करता?

Question

Accepted Answer

Ruby **methods** `def...end` सह व्यक्त केल्या जातात. Ruby मध्ये लचकदार, अभिव्यक्तिशील वितर्क हाताळणी आहे — डिफॉल्ट मूल्ये, keyword arguments, splat (`*`) variable arguments साठी, आणि blocks — तसेच **शेवटची expression implicit return value म्हणून परत केली जाते** या नियमाचा प्रथा आहे.

## मूलभूत methods आणि 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 साठी वापरले जाते). हा idiom आहे.

## डिफॉल्ट आणि 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:`) हे आधुनिक Ruby च्या idiomatic मार्गाचे उदाहरण आहेत — ते calls स्वयं-दस्तावेज करतात आणि क्रम-स्वतंत्र असतात.

## 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 मध्ये; `**options` keyword arguments एकत्र करून hash मध्ये.

## ? आणि ! मध्ये संपणारे methods

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

नामकरण नियम: **`?`** मध्ये संपणारे methods boolean परत करतात (predicates), आणि **`!`** destructive/in-place किंवा "धोकादायक" आवृत्ती दर्शवते.

## हे का महत्त्वाचे आहे

Methods हे Ruby मधील वर्तनाचे बिल्डिंग ब्लॉक्स आहेत, आणि Ruby च्या लचकदार, अभिव्यक्तिशील वितर्क हाताळणी आणि नियमांची समज हे महत्त्वाचे दैनंदिन ज्ञान आहे.

काही पैलू विशिष्टपणे Ruby चे आहेत आणि ज्ञानार्थ महत्त्वाचे आहेत: **implicit return** (methods शेवटच्या evaluated expression परत करतात, म्हणून `return` क्वचित लिहिले जाते — idiomatic Ruby यावर अवलंबून आहे), **keyword arguments** (`name:` — स्पष्ट, self-documenting, order-independent method calls लिहिण्याचा आधुनिक, idiomatic मार्ग), आणि **splat arguments** (`*args`/`**options` variable numbers साठी).

समान महत्त्वाचे **नामकरण नियम** आहेत — **`?`** मध्ये संपणारे methods हे predicates असतात जे booleans परत करतात (`valid?`, `empty?`), आणि **`!`** मध्ये संपणारे methods destructive/in-place किंवा "धोकादायक" आवृत्त्या आहेत (`map!`, `sort!`) — जे Ruby आणि Rails मध्ये व्यापक आहेत आणि एका दृष्टीक्षेपात method च्या वर्तनाचे संचार करतात (`!` विशेषत: "in-place सुधारणा" म्हणून अर्थ असणे अनावधानाने mutations टाळण्यासाठी महत्त्वाचे आहे).

Ruby च्या लचकदार arguments (defaults, keywords, splats) सह methods कशी व्यक्त करायची, implicit-return idiom, आणि `?`/`!` नामकरण नियम यांची समज हे idiomatic Ruby लिहिण्यासाठी आणि वाचण्यासाठी पायाभूत आहे — हे वैशिष्ट्ये आणि नियम सतत दिसतात, आणि त्यांची समज (विशेषत: clean APIs साठी keyword arguments आणि method behavior समजण्यासाठी `?`/`!` नियम) effective Ruby development साठी आवश्यक, वारंवार-लागू केलेले ज्ञान आहे.