ਇਹ Ruby ਵਿੱਚ ਕੋਡ ਦੇ ਟੁਕੜਿਆਂ ਨੂੰ ਡਾਟਾ ਵਜੋਂ ਸੰਭਾਲਣ ਦੇ ਤਿੰਨ ਤਰੀਕੇ ਹਨ। ਇੱਕ ਬਲਾਕ ਇੱਕ ਮੈਥਡ ਨੂੰ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ (ਕੋਈ ਆਬਜੈਕਟ ਨਹੀਂ); ਇੱਕ Proc ਅਤੇ ਇੱਕ lambda ਆਬਜੈਕਟ ਹਨ ਜੋ ਇੱਕ ਬਲਾਕ ਨੂੰ ਮੋੜਦੇ ਹਨ (ਕਾਲਯੋਗ, ਸਟੋਰ ਕਰਨ ਯੋਗ)। Procs ਅਤੇ lambdas ਆਰਗੂਮੈਂਟ ਚੈਕਿੰਗ ਅਤੇ return ਦੇ ਵਰਤਾਓ ਵਿੱਚ ਸੂਖਮ ਫ਼ਰਕ ਰੱਖਦੇ ਹਨ।
[1, 2, 3].each { |n| puts n } # the { } is a block — passed to each
# a block is NOT an object; it's part of the method call, can't be stored in a variable directly
ਇੱਕ ਬਲਾਕ ਉਹ ਕੋਡ ਹੈ ਜੋ ਇੱਕ ਮੈਥਡ ਨੂੰ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ({ } ਜਾਂ do...end ਵਿੱਚ) — ਇਹ ਇੱਕ ਸਟੈਂਡਅਲੋਨ ਆਬਜੈਕਟ ਨਹੀਂ ਜਿਸ ਨੂੰ ਤੁਸੀਂ ਸਟੋਰ ਕਰ ਸਕੋ; ਇਹ ਮੈਥਡ ਕਾਲ ਨਾਲ ਜੁੜਿਆ ਹੋਇਆ ਹੈ।
# a Proc — a block turned into an object you can store and call
square = Proc.new { |x| x * x }
square.call(5) # 25
square.(5) # 25 (alternate call syntax)
# a lambda — also a callable object (a "stricter" Proc)
double = lambda { |x| x * 2 }
double = ->(x) { x * 2 } # the -> "stabby lambda" syntax
double.call(5) # 10
Procs ਅਤੇ lambdas ਇੱਕ ਬਲਾਕ ਨੂੰ ਇੱਕ ਆਬਜੈਕਟ ਵਿੱਚ ਮੋੜਦੇ ਹਨ ਜਿਸ ਨੂੰ ਤੁਸੀਂ ਵੇਰੀਏਬਲਾਂ ਨਾਲ ਅਸਾਈਨ ਕਰ ਸਕੋ, ਆਲੇ ਦੁਆਲੇ ਪਾਸ ਕਰ ਸਕੋ, ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਕਾਲ ਕਰ ਸਕੋ (.call) — ਮੁੜ ਵਰਤੋ ਯੋਗ ਵਰਤਾਰਏ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਮਫ਼ੀਦ।
1. ARGUMENT CHECKING:
lambda → STRICT: errors if wrong number of arguments (like a method)
proc → LENIENT: ignores extra args, fills missing with nil
2. RETURN behavior:
lambda → `return` returns from the LAMBDA (like a normal method)
proc → `return` returns from the ENCLOSING METHOD (can surprise you!)
def test_proc
p = Proc.new { return 10 }
p.call # returns from test_proc ENTIRELY → 10
return 20 # never reached!
end
def test_lambda
l = lambda { return 10 }
l.call # returns from the LAMBDA only → 10
return 20 # reached → test_lambda returns 20
end
ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਅੰਤਰ: ਇੱਕ lambda ਇੱਕ ਮੈਥਡ ਵਰਗਾ ਆਚਰਨ ਕਰਦਾ ਹੈ (ਸਖ਼ਤ ਆਰਗੂਮੈਂਟ, return ਸਿਰਫ਼ lambda ਤੋਂ ਬਾਹਰ ਆ ਜਾਂਦਾ ਹੈ), ਜਦੋਂ ਕਿ ਇੱਕ proc ਵਧੇਰੇ ਨਰਮ ਹੈ (ਆਰਗੂਮੈਂਟ ਬੇਮੇਲ ਨੂੰ ਨਜ਼ਰ ਅੰਦਾਜ਼ ਕਰਦਾ ਹੈ, ਅਤੇ return ਆਲੇ ਦੁਆਲੇ ਮੈਥਡ ਤੋਂ ਬਾਹਰ ਆ ਜਾਂਦਾ ਹੈ — ਜੋ ਹੈਰਾਨ ਕੁਨ ਵਰਤਾਓ ਕਾ ਸਬੱਬ ਬਨ ਸਕਦਾ ਹੈ)। Lambdas ਆਮ ਤੌਰ ਤੇ ਤਰਜੀਹ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ ਕਿਉਂਕਿ ਉਨ੍ਹਾਂ ਦਾ ਮੈਥਡ-ਵਰਗਾ, ਪੂਰਵ ਅਨੁਮਾਨਯੋਗ ਵਰਤਾਓ ਹੈ।
blocks, procs, ਅਤੇ lambdas ਨੂੰ ਸਮਝਨਾ — ਅਤੇ ਖ਼ਾਸ ਕਰਕੇ ਉਨ੍ਹਾਂ ਦੇ ਅੰਤਰ — ਮਹੱਤਵਪੂਰਨ Ruby ਗਿਆਨ ਹੈ ਜੋ ਇਸ ਦੇ ਡੂੰਘੇ ਵਿਚਾਰ ਨੂੰ ਝਲਕਾਉਂਦਾ ਹੈ ਕਿ Ruby ਕੋਡ ਨੂੰ ਡਾਟਾ ਦੇ ਤੌਰ ਤੇ ਕਿਵੇਂ ਸੰਭਾਲਦਾ ਹੈ। Blocks ਸਭ ਤੋਂ ਆਮ ਹਨ (ਮੈਥਡਾਂ ਨੂੰ iteration ਅਤੇ callbacks ਲਈ ਪਾਸ ਕੀਤੇ — Ruby ਦੀ ਪਛਾਣ ਦੀ ਵਿਸ਼ੇਸ਼ਤਾ), ਜਦੋਂ ਕਿ procs ਅਤੇ lambdas blocks ਨੂੰ ਸਟੋਰ ਕਰਨ ਯੋਗ, ਮੁੜ ਵਰਤੋ ਯੋਗ ਆਬਜੈਕਟਾਂ ਵਿੱਚ ਬਦਲ ਦਿੰਦੇ ਹਨ ਜਿਨ੍ਹਾਂ ਨੂੰ ਤੁਸੀਂ ਵੇਰੀਏਬਲਾਂ ਨਾਲ ਅਸਾਈਨ ਕਰ ਸਕੋ, ਆਲੇ ਦੁਆਲੇ ਪਾਸ ਕਰ ਸਕੋ, ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਕਾਲ ਕਰ ਸਕੋ (ਵਰਤਾਰਾ ਸਟੋਰ ਕਰਨ, ਫੰਕਸ਼ਨਲ ਪੈਟਰਨ ਬਣਾਉਣ, ਅਤੇ callbacks ਨੂੰ ਮੁੱਲਾਂ ਦੇ ਤੌਰ ਤੇ ਪਾਸ ਕਰਨ ਲਈ ਮਫ਼ੀਦ)।
Procs ਅਤੇ lambdas ਵਿਚਾਲੇ ਮੁੱਖ ਅੰਤਰ ਸੂਖਮ ਪਰ ਮਹੱਤਵਪੂਰਨ ਹਨ ਅਤੇ ਇਕ ਅਕਸਰ interview ਵਿਸ਼ਾ ਹਨ: ਆਰਗੂਮੈਂਟ ਚੈਕਿੰਗ (lambdas ਮੈਥਡਾਂ ਵਾਂਗ ਸਖ਼ਤ ਹਨ, procs ਨਰਮ ਹਨ) ਅਤੇ ਖ਼ਾਸ ਕਰਕੇ return ਦਾ ਵਰਤਾਓ (ਇੱਕ lambda ਦਾ return ਸਿਰਫ਼ lambda ਤੋਂ ਬਾਹਰ ਆ ਜਾਂਦਾ ਹੈ, ਜਦੋਂ ਕਿ ਇੱਕ proc ਦਾ return ਆਲੇ ਦੁਆਲੇ ਮੈਥਡ ਤੋਂ ਬਾਹਰ ਆ ਜਾਂਦਾ ਹੈ — ਜੋ ਹੈਰਾਨ ਕੁਨ, ਸੋਧਣ ਵਿੱਚ ਔਖਾ ਵਰਤਾਓ ਕਾ ਸਬੱਬ ਬਨ ਸਕਦਾ ਹੈ)।
ਇਹ ਪਰਖ ਕਰਨਾ ਕਿ ਇੱਕ lambda ਇੱਕ ਮੈਥਡ ਵਾਂਗ ਆਚਰਨ ਕਰਦਾ ਹੈ (ਸਖ਼ਤ, ਪੂਰਵ ਅਨੁਮਾਨਯੋਗ, ਸਥਾਨਿਕ return ਦੇ ਨਾਲ) ਜਦੋਂ ਕਿ ਇੱਕ proc ਆਸ਼ਚਰਯਜਨਕ return ਕ ਨਾਲ ਵਧੇਰੇ ਨਰਮ ਹੈ — ਉਨ੍ਹਾਂ ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਵਰਤਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ ਅਤੇ lambdas ਨੂੰ ਤਰਜੀਹ ਦੇਣ ਦੀ ਆਮ ਸਿਫ਼ਾਰਸ਼ ਲਈ ਉਨ੍ਹਾਂ ਦੀ ਪੂਰਵ ਅਨੁਮਾਨਯੋਗ, ਮੈਥਡ-ਵਰਗੀ ਵਰਤਾ ਲਈ।
ਜਦੋਂ ਕਿ blocks ਹਰ ਰੋਜ਼ Ruby ਹਨ ਅਤੇ procs/lambdas ਸਟੋਰ ਯੋਗ callbacks ਅਤੇ ਫੰਕਸ਼ਨਲ ਪੈਟਰਨ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ, ਤਿਨੋਂ ਨੂੰ ਸਮਝਨਾ (ਖ਼ਾਸ ਤੌਰ ਤੇ proc-vs-lambda return ਅਤੇ ਆਰਗੂਮੈਂਟ ਅੰਤਰ) ਠੋਸ Ruby ਜਾਨ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ, ਤੁਹਾਨੂੰ proc-return gotcha ਤੋਂ ਬਚਾਅ ਦਿਲਵਾਉਂਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਪਰਿਭਾਸ਼ਤ ਵਿਸ਼ਾ ਹੈ ਜੋ ਉਨ੍ਹਾਂ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਵੱਖ ਕਰਦਾ ਹੈ ਜੋ ਸੱਚਮੁੱਚ Ruby ਦਾ ਸਮਝਦੇ ਹਨ।