Ruby ਮੇਥਡਜ਼ ਨੂੰ def...end ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। Ruby ਵਿੱਚ ਲਚਕਦਾਰ, ਅਭਿਵਿਆਕਤਾ ਵਾਲਾ ਆਰਗੂਮੈਂਟ ਹ್ਯਾਂਡਲਿੰਗ ਹੈ — ਡਿਫੌਲਟ ਵੈਲਿਊਜ਼, keyword ਆਰਗੂਮੈਂਟਸ, splat (*) ਵੇਰੀਏਬਲ ਆਰਗੂਮੈਂਟਸ ਲਈ, ਅਤੇ blocks — ਨਾਲ ਹੀ ਇਹ ਕਨਵੈਨਸ਼ਨ ਕਿ ਆਖਰੀ ਐਕਸਪ੍ਰੈਸ਼ਨ ਬਿਨਾਂ ਲਿਖੇ ਰਿਟਰਨ ਵੈਲਿਊ ਹੈ।
()
a + b
add(, )
()
Ruby ਮੇਥਡਜ਼ ਆਖਰੀ ਮੁਲਤਾਂਕਿਤ ਐਕਸਪ੍ਰੈਸ਼ਨ ਨੂੰ ਖੁਦਕਾਰ ਵਾਪਸ ਕਰਦੇ ਹਨ — ਤੁਸੀਂ ਸ਼ਾਇਦ ਹੀ return ਲਿਖਦੇ ਹੋ (ਇਸ ਦੀ ਵਰਤੋਂ ਸਿਰਫ ਜਲਦੀ ਆਉਣ ਲਈ ਕੀ ਜਾਂਦੀ ਹੈ)। ਇਹ 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 ਆਰਗੂਮੈਂਟਸ (name:) idiomatic ਆਧੁਨਿਕ 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 ਆਰਗੂਮੈਂਟਸ ਨੂੰ ਐਰੇ ਵਿੱਚ ਇਕੱਠਾ ਕਰਦੇ ਹਨ; **options keyword ਆਰਗੂਮੈਂਟਸ ਨੂੰ 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
Naming ਕਨਵੈਨਸ਼ਨਜ਼: ਜੋ ਮੇਥਡਜ਼ ? ਉੱਤੇ ਖਤਮ ਹੁੰਦੇ ਹਨ ਉਹ booleans (predicates) ਵਾਪਸ ਕਰਦੇ ਹਨ, ਅਤੇ ! ਇੱਕ destructive/in-place ਜਾਂ "ਖ਼ਤਰਨਾਕ" ਸੰਸਕਰਣ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।
Methods Ruby ਵਿੱਚ ਵਿਆਵਹਾਰ ਦੀਆਂ ਬਿੱਲੀਆਂ ਹਨ, ਅਤੇ Ruby ਦੇ ਲਚਕਦਾਰ, ਅਭਿਵਿਆਕਤਾ ਵਾਲੇ ਆਰਗੂਮੈਂਟ ਹ್ਯਾਂਡਲਿੰਗ ਅਤੇ ਕਨਵੈਨਸ਼ਨਜ਼ ਨੂੰ ਸਮਝਣਾ ਰੋਜ਼ਾਨਾ ਮਹੱਤਵਪੂਰਨ ਗਿਆਨ ਹੈ।
ਕਈ ਪਹਲੂ ਵਿਸ਼ੇਸ਼ ਰੂਪ ਨਾਲ Ruby ਦੇ ਹਨ ਅਤੇ ਜਾਣਦੇ ਜਾਣ ਯੋਗ ਹਨ: ਬਿਨਾਂ ਲਿਖੀ return (methods ਆਖਰੀ ਮੁਲਤਾਂਕਿਤ ਐਕਸਪ੍ਰੈਸ਼ਨ ਨੂੰ ਵਾਪਸ ਕਰਦੇ ਹਨ, ਤਾਂ return ਸ਼ਾਇਦ ਹੀ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ — idiomatic Ruby ਇਸ ਉੱਪਰ ਭਰੋਸਾ ਕਰਦਾ ਹੈ), keyword ਆਰਗੂਮੈਂਟਸ (name: — ਸਪਸ਼ਟ, self-documenting, order-independent method calls ਲਿਖਣ ਦਾ ਆਧੁਨਿਕ, idiomatic ਤਰੀਕਾ), ਅਤੇ splat ਆਰਗੂਮੈਂਟਸ (*args/**options ਵੇਰੀਏਬਲ ਆਰਗੂਮੈਂਟਸ ਲਈ)।
ਬਰਾਬਰ ਮਹੱਤਵਪੂਰਨ naming ਕਨਵੈਨਸ਼ਨਜ਼ ਹਨ — ਜੋ methods ? ਉੱਤੇ ਖਤਮ ਹੁੰਦੇ ਹਨ ਉਹ booleans ਵਾਪਸ ਕਰਨ ਵਾਲੇ predicates ਹਨ (valid?, empty?), ਅਤੇ ! ਉੱਤੇ ਖਤਮ ਹੋਣ ਵਾਲੇ methods destructive/in-place ਜਾਂ "ਖ਼ਤਰਨਾਕ" ਸੰਸਕਰਣ ਹਨ (map!, sort!) — ਜੋ Ruby ਅਤੇ Rails ਵਿੱਚ ਵਿਆਪਕ ਹਨ ਅਤੇ ਇੱਕ method ਦੇ ਵਿਆਵਹਾਰ ਨੂੰ ਪਹਿਲੀ ਨਜ਼ਰ ਵਿੱਚ ਦਰਸਾਉਂਦੇ ਹਨ (ਜਾਣਨਾ ਕਿ ! ਆਮ ਤੌਰ ਉੱਤੇ "in place ਨੂੰ modify ਕਰਦਾ ਹੈ" ਅਜਿਹਾ ਬਿਨਾ ਇਰਾਦੇ ਦੇ mutations ਤੋਂ ਬਚਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ)।
Ruby ਦੇ ਲਚਕਦਾਰ ਆਰਗੂਮੈਂਟਸ (defaults, keywords, splats) ਦੇ ਨਾਲ ਮੇਥਡਜ਼ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਸਮਝਣਾ, ਬਿਨਾਂ ਲਿਖੀ-return idiom, ਅਤੇ ?/! naming ਕਨਵੈਨਸ਼ਨਜ਼ idiomatic Ruby ਲਿਖਣ ਅਤੇ ਪੜ੍ਹਨ ਲਈ ਬੁਨਿਆਦੀ ਹਨ — ਇਹ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਕਨਵੈਨਸ਼ਨਜ਼ ਲਗਾਤਾਰ ਮੌਜੂਦ ਹਨ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਸਮਝਣਾ (ਖਾਸ ਕਰਕੇ clean APIs ਲਈ keyword ਆਰਗੂਮੈਂਟਸ ਅਤੇ method ਵਿਆਵਹਾਰ ਨੂੰ ਸਮਝਣ ਲਈ ?/! ਕਨਵੈਨਸ਼ਨਜ਼) ਪ੍ਰਭਾਵਸ਼ਾਲੀ Ruby development ਲਈ ਜਰੂਰੀ, ਅਕਸਰ-ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਗਿਆਨ ਹੈ।