તમે દલીલો સાથે મેથડ્સ કેવી રીતે વ્યાખ્યાયિત કરો છો?

Question

IT Interview Practice · Accepted Answer

Ruby **મેથડ્સ** `def...end` સાથે વ્યાખ્યાયિત કરવામાં આવે છે. Ruby લવણીય, અભિવ્યક્તિશીલ દલીલ હેન્ડલિંગ ધરાવે છે — ડિફોલ્ટ મૂલ્યો, કીવર્ડ દલીલો, સ્પ્લેટ (`*`) ચલ દલીલો માટે, અને બ્લોક્સ — વધુમાં એ સંમેલન કે **છેલ્લી અભિવ્યક્તિ 暗 implicit રીટર્ન વેલ્યુ છે**।

## મૂળભૂત મેથડ્સ અને 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 મેથડ્સ **છેલ્લી મૂલ્યાંકિત અભિવ્યક્તિ આપમેળે રીટર્ન** કરે છે — તમે ભાગ્યે જ `return` લખો છો (તેનો ઉપયોગ માત્ર વહેલા રીટર્નો માટે થાય છે). આ ભાષાના રીતિ છે।

## ડિફોલ્ટ અને કીવર્ડ દલીલો

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

**કીવર્ડ દલીલો** (`name:`) આધુનિક Ruby માં ભાષાના રીતિ છે — તેઓ કૉલ્સને સ્વ-નોંધાયેલ અને ક્રમ-સ્વતંત્ર બનાવે છે।

## સ્પ્લેટ દલીલો (ચલ સંખ્યા)

```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` ચલ પોઝિશનલ દલીલોને એરેમાં એકત્રિત કરે છે; `**options` કીવર્ડ દલીલોને હેશમાં એકત્રિત કરે છે।

## ? અને ! માં સમાપ્ત થતી મેથડ્સ

```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) રીટર્ન કરે છે, અને **`!`** વિનાશક/in-place અથવા "જોખમી" સંસ્કરણ સૂચવે છે।

## તે શા માટે મહત્ત્વપૂર્ણ છે

મેથડ્સ Ruby માં વર્તણૂકના મૂળ બ્લોક્સ છે, અને Ruby ના લવણીય, અભિવ્યક્તિશીલ દલીલ હેન્ડલિંગ અને સંમેલનો સમજવું રોજિંદા મહત્ત્વપૂર્ણ જ્ઞાન છે।

તમામ પાસાઓમાંથી કેટલાક distinctly Ruby છે અને જાણવા યોગ્ય છે: **implicit return** (મેથડ્સ છેલ્લી મૂલ્યાંકિત અભિવ્યક્તિ રીટર્ન કરે છે, તેથી `return` ભાગ્યે જ લખાય છે — ભાષાના રીતિ આના પર આધાર રાખે છે), **કીવર્ડ દલીલો** (`name:` — સ્પષ્ટ, સ્વ-નોંધાયેલ, ક્રમ-સ્વતંત્ર મેથડ કૉલ્સ લખવાનો આધુનિક, ભાષાના રીતિ તરીકો), અને **સ્પ્લેટ દલીલો** (`*args`/`**options` દલીલોની ચલ સંખ્યા માટે)।

સમાન રીતે મહત્ત્વપૂર્ણ **નામ આપવાની સંમેલનો** છે — **`?`** માં સમાપ્ત થતી મેથડ્સ બુલિયન્સ પરત કરતી predicates છે (`valid?`, `empty?`), અને **`!`** માં સમાપ્ત થતી મેથડ્સ વિનાશક/in-place અથવા "જોખમી" સંસ્કરણો છે (`map!`, `sort!`) — જે Ruby અને Rails માં વ્યાપક છે અને એક નજરમાં મેથડના વર્તણૂક વર્ણવે છે (જાણવું કે `!` સામાન્યતઃ "in place માં સુધારે છે" એ અનિચ્છનીય ફેરફારોને ટાળવા માટે મહત્ત્વપૂર્ણ છે)।

Ruby ના લવણીય દલીલો (ડિફોલ્ટ્સ, કીવર્ડ્સ, splats) સાથે મેથડ્સ સમજવું, implicit-return ભાષાના રીતિ, અને `?`/`!` નામ આપવાની સંમેલનો idiomatic Ruby લખવા અને વાંચવા માટે ভিત્તિ છે — આ વૈશિષ્ટ્યો અને સંમેલનો સતત દેખાય છે, અને તેમને સમજવું (ખાસ કરીને સ્વચ્છ APIs માટે કીવર્ડ દલીલો અને મેથડ વર્તણૂક સમજવા માટે `?`/`!` સંમેલનો) અસરકારક Ruby વિકાસ માટે આવશ્યક, વારંવાર-લાગુ જ્ઞાન છે।

મૂળભૂત મેથડ્સ અને implicit return

ડિફોલ્ટ અને કીવર્ડ દલીલો

સ્પ્લેટ દલીલો (ચલ સંખ્યા)

? અને ! માં સમાપ્ત થતી મેથડ્સ

તે શા માટે મહત્ત્વપૂર્ણ છે

સંબંધિત પ્રશ્નો