Ruby મેથડ્સ def...end સાથે વ્યાખ્યાયિત કરવામાં આવે છે. Ruby લવણીય, અભિવ્યક્તિશીલ દલીલ હેન્ડલિંગ ધરાવે છે — ડિફોલ્ટ મૂલ્યો, કીવર્ડ દલીલો, સ્પ્લેટ (*) ચલ દલીલો માટે, અને બ્લોક્સ — વધુમાં એ સંમેલન કે છેલ્લી અભિવ્યક્તિ 暗 implicit રીટર્ન વેલ્યુ છે।
()
a + b
add(, )
()
Ruby મેથડ્સ છેલ્લી મૂલ્યાંકિત અભિવ્યક્તિ આપમેળે રીટર્ન કરે છે — તમે ભાગ્યે જ return લખો છો (તેનો ઉપયોગ માત્ર વહેલા રીટર્નો માટે થાય છે). આ ભાષાના રીતિ છે।
# 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 માં ભાષાના રીતિ છે — તેઓ કૉલ્સને સ્વ-નોંધાયેલ અને ક્રમ-સ્વતંત્ર બનાવે છે।
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 કીવર્ડ દલીલોને હેશમાં એકત્રિત કરે છે।
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 વિકાસ માટે આવશ્યક, વારંવાર-લાગુ જ્ઞાન છે।