நீங்கள் வாதங்களுடன் முறைகளை எவ்வாறு வரையறுக்கிறீர்கள்?

Question

Accepted Answer

Ruby **methods** ஆனது `def...end` மூலம் வரையறுக்கப்படுகிறது. Ruby நমনীய, வெளிப்படையான வாத கையாளுதல் கொண்டுள்ளது — இயல்பாக மதிப்புகள், keyword arguments, splat (`*`) மாறி வாதங்களுக்கு, மற்றும் blocks — மேலும் **கடைசி வெளிப்பாடு மறைமுக வரும் மதிப்பு** என்ற மரபு.

## அடிப்படை methods மற்றும் மறைமுக 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 **கடைசியாக மதிப்பிடப்பட்ட வெளிப்பாட்டை தானாக வழங்குகின்றன** — நீங்கள் `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 இன் idiom — அவை அழைப்புகளை சுய-ஆவணப்படுத்துதல் மற்றும் வரிசை-சுயாதீன செய்கிறது.

## Splat arguments (மாறி எண்ணிக்கை)

```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` மாறி நிலை வாதங்களை 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), மற்றும் **`!`** ஒரு நாசகரமான/in-place அல்லது "ஆபத்தான" பதிப்பைக் குறிக்கிறது.

## இது ஏன் முக்கியமாக இருக்கிறது

Methods Ruby இல் நடத்தையின் கட்டுமான தொகுதிகளாக இருக்கின்றன, மற்றும் Ruby இன் நமனீயமான, வெளிப்படையான வாத கையாளுதல் மற்றும் மரபுகளைப் புரிந்துகொள்வது முக்கியமான அன்றாட அறிவாகும்.

பல அம்சங்கள் தனித்துவமாக Ruby மற்றும் அறிந்து வைத்திருப்பது மதிப்பு வாய்ந்தவை: **மறைமுக return** (methods கடைசி மதிப்பிடப்பட்ட வெளிப்பாட்டை வழங்குகின்றன, எனவே `return` அரிதாகவே எழுதப்படுகிறது — idiom Ruby இ இந்த மீது நம்பியிருக்கிறது), **keyword arguments** (`name:` — தெளிவான, சுய-ஆவணப்படுத்துதல், வரிசை-சுயாதீன முறை அழைப்புகளை எழுதுவதற்கான modernமான, idiom வழி), மற்றும் **splat arguments** (`*args`/`**options` வாதங்களின் மாறி எண்ணிக்கைக்கு).

சমানளவு முக்கியமாகவே **பெயரிடும் மரபுகள்** — **`?`** முடிவடையும் methods predicates boolean களை வழங்குகின்றன (`valid?`, `empty?`), மற்றும் **`!`** முடிவடையும் methods நாசகரமான/in-place அல்லது "ஆபத்தான" பதிப்புகள் (`map!`, `sort!`) — Ruby மற்றும் Rails இல் பொதுவாக இருக்கின்றன மற்றும் ஒரு பார்வையில் ஒரு method இன் நடத்தையை தொடர்பு கொள்ளுகின்றன (அந்த `!` பொதுவாக "in-place ஆ மாற்றம் செய்கிறது" என்பது அறிந்து வைத்திருப்பது அநேக மாறுபாடுகளைத் தடுப்பதற்கு முக்கியமாக இருக்கிறது).

Ruby இன் நমனீயமான வாத வரையறுத்தல் (defaults, keywords, splats) முறை வரையறுக்க எவ்வாறு வேண்டும் என்பது புரிந்துகொள்ளுதல், மறைமுக-return idiom, மற்றும் `?`/`!` பெயரிடும் மரபுகள் idiom Ruby எழுதுதல் மற்றும் படிப்பதற்கு அடிப்படையாக இருக்கிறது — இந்த features மற்றும் மரபுகள் கொடிரையாக தோன்றுகின்றன, மற்றும் அவற்றை புரிந்துகொள்ளுதல் (குறிப்பாக পরிষ்கார APIs க்கான keyword arguments மற்றும் method நடத்தையை புரிந்துகொள்ளுவதற்கான `?`/`!` மரபுகள்) Ruby மேம்பாட்டிற்கான பயனுள்ள அவசியமான, அடிக்கடி-பயன்படுத்தப்படும் அறிவாக இருக்கிறது.