Ruby methods లను def...end తో డిఫైన్ చేస్తారు. Ruby చాలా ఫ్లెక్సిబుల్, ఎక్సప్రెసివ్ ఆర్గ్యుమెంట్ హ్యాండ్లింగ్ కలిగి ఉంది — డిఫాల్ట్ వ్యాల్యూలు, keyword arguments, splat (*) వేరియబుల్ ఆర్గ్యుమెంట్ల కోసం, మరియు blocks — ప్లస్ కన్వెన్షన్ ఆ చివరి expression implicit return value.
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 చివరిగా evaluate చేసిన expression ను ఆటోమేటిక్గా return చేస్తాయి — నీవు చాలా అరుదుగా return రాస్తావు (ఇది early returns కోసం మాత్రమే ఉపయోగించబడుతుంది). ఇది idiomatic.
# 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 చేస్తాయి.
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 వేరియబుల్ positional arguments ను array లోకి సేకరిస్తుంది; **options keyword arguments ను hash లోకి సేకరిస్తుంది.
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 బూలియన్లను return చేస్తాయి (predicates), మరియు ! ఒక విధ్వంసక/in-place లేదా "ఖతరనాక" వర్షన్ను సూచిస్తుంది.
Methods Ruby లో behavior యొక్క బిల్డింగ్ బ్లాక్లు, మరియు Ruby యొక్క ఫ్లెక్సిబుల్, ఎక్సప్రెసివ్ argument handling మరియు కన్వెన్షన్లను అర్థం చేసుకోవడం ఉపయోగకరమైన రోజువారీ జ్ఞానం.
చాలా కొన్ని అంశాలు విలక్షణంగా Ruby మరియు తెలుసుకోవడానికి విలువైనవి: implicit return (methods చివరిగా evaluate చేసిన expression ను return చేస్తాయి, కనుక return చాలా అరుదుగా రాస్తారు — idiomatic Ruby ఇది పై ఆధారపడుతుంది), keyword arguments (name: — స్పష్టమైన, self-documenting, order-independent method calls రాయడానికి ఆధునిక, idiomatic మార్గం), మరియు splat arguments (*args/**options ఆర్గ్యుమెంట్ల వేరియబుల్ సంఖ్యల కోసం).
సమానంగా ముఖ్యమైనవి నామకరణ కన్వెన్షన్లు — ? తో ముగిసే methods బూలియన్లను return చేసే predicates (valid?, empty?), మరియు ! తో ముగిసే methods విధ్వంసక/in-place లేదా "ఖతరనాక" వర్షన్లు (map!, sort!) — ఇవి Ruby మరియు Rails లో విస్తృతమైనవి మరియు method యొక్క behavior ని ఒక చేతిని కమ్ముకుంటూ సంప్రదాయం చేస్తాయి (! సాధారణంగా "in place లో మార్పులు" అని అర్థం ఇది తెలుసుకోవడం ఉద్దేశ్యం లేని mutations ను నివారించడానికి ముఖ్యమైనది).
Ruby యొక్క ఫ్లెక్సిబుల్ arguments (defaults, keywords, splats) తో methods ను డిఫైన్ చేయడం, implicit-return idiom, మరియు ?/! నామకరణ కన్వెన్షన్లను అర్థం చేసుకోవడం idiomatic Ruby రాయడం మరియు చదవడం కోసం ఫౌండేషనల్ — ఈ ఫీచర్లు మరియు కన్వెన్షన్లు నిరంతరం కనిపిస్తాయి, మరియు వాటిని గ్రహించడం (ప్రత్యేకించి clean APIs కోసం keyword arguments మరియు method behavior ను అర్థం చేసుకోవడానికి ?/! కన్వెన్షన్లు) సమర్థవంతమైన Ruby development కోసం అవసరమైన, తరచుగా-ఉపయోగిస్తారు జ్ఞానం.