Dessa är tre sätt Ruby hanterar kodblock som data. Ett block skickas till en metod (inte ett objekt); en Proc och en lambda är objekt som omsluter ett block (anropbara, lagringsbar). Procs och lambdas skiljer sig subtilt i argument-kontroll och return-beteende.
[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
Ett block är koden som skickas till en metod (i { } eller do...end) — det är inte ett fristående objekt du kan lagra; det är knutet till metodanropet.
# 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 och lambdas omsluter ett block till ett objekt du kan tilldela variabler, skicka runt och anropa senare (.call) — användbart för att lagra återanvändbar beteende.
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
Den viktigaste skillnaden: en lambda beter sig som en metod (strikta argument, return avslutar bara lambdan), medan en proc är mer tillåtande (ignorerar argument-misspass, och return avslutar den omslutande metoden — vilket kan orsaka överraskande beteende). Lambdas föredras generellt för sitt metodliknande, förutsägbara beteende.
Att förstå blocks, procs och lambdas — och särskilt deras skillnader — är viktig Ruby-kunskap som speglar en djupare förståelse för hur Ruby hanterar kod som data. Blocks är mest vanliga (skickade till metoder för iteration och callbacks — Rubys signaturfunktion), medan procs och lambdas förvandlar blocks till lagringsbar, återanvändbar objekt du kan tilldela variabler, skicka runt och anropa senare (användbart för att lagra beteende, bygga funktionella mönster och skicka callbacks som värden).
De viktigaste skillnaderna mellan procs och lambdas är subtila men viktiga och ett vanligt intervjuämne: argument-kontroll (lambdas är strikta som metoder, procs är tillåtande) och särskilt return-beteende (en lambdas return avslutar bara lambdan, medan en procs return avslutar den omslutande metoden — vilket kan orsaka överraskande, svårfelsökt beteende).
Att förstå dessa distinktioner — att en lambda beter sig som en metod (sträng, förutsägbar, med lokaliserad return) medan en proc är mer tillåtande med överraskande return-semantik — är viktigt för att använda dem korrekt och för den vanliga rekommendationen att föredra lambdas för deras förutsägbara, metodliknande beteende.
Even om blocks är vardags-Ruby och procs/lambdas används för lagringsbar callbacks och funktionella mönster, är förståelse av alla tre (särskilt proc-vs-lambda return och argument-skillnaderna) ett tecken på solid Ruby-kunskap, hjälper dig att undvika proc-return-gotchan och är ett klassiskt intervjuämne som skiljer utvecklare som verkligen förstår Rubys hantering av kod som objekt.