Dit zijn drie manieren waarop Ruby chunks code als data afhandelt. Een block wordt doorgegeven aan een methode (niet een object); een Proc en een lambda zijn objecten die een block verpakken (callable, opslaanbaar). Procs en lambdas verschillen subtiel in argument checking en return gedrag.
Blocks — doorgegeven aan methodes (geen objecten)
[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
Een block is de code doorgegeven aan een methode (in { } of do...end) — het is geen zelfstandig object dat je kunt opslaan; het is gekoppeld aan de methode call.
Procs en lambdas — blocks als opslaanbare objecten
# 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 en lambdas verpakken een block in een object dat je aan variabelen kunt toewijzen, kunt doorgegeven, en later kunt aanroepen (.call) — nuttig voor het opslaan van herbruikbaar gedrag.
De belangrijkste verschillen: argumenten en return
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
Het meest belangrijke verschil: een lambda gedraagt zich als een methode (strikte argumenten, return verlaat alleen de lambda), terwijl een proc meer soepel is (negeert argument incompatibiliteiten, en return verlaat de omsluitende methode — wat verrassend gedrag kan veroorzaken). Lambdas hebben over het algemeen de voorkeur vanwege hun methode-achtige, voorspelbare gedrag.
Waarom het belangrijk is
Het begrijpen van blocks, procs en lambdas — en vooral hun verschillen — is belangrijk Ruby-kennis die een dieper begrip weerspiegelt van hoe Ruby code als data afhandelt. Blocks zijn het meest voorkomend (doorgegeven aan methodes voor iteratie en callbacks — Ruby's handtekenfunctie), terwijl procs en lambdas blocks in opslaanbare, herbruikbare objecten veranderen die je aan variabelen kunt toewijzen, kunt doorgegeven en later kunt aanroepen (nuttig voor het opslaan van gedrag, het bouwen van functionele patronen, en het doorgegeven van callbacks als waarden).
De belangrijkste verschillen tussen procs en lambdas zijn subtiel maar belangrijk en een veelvoorkomend interviewonderwerp: argument checking (lambdas zijn streng als methodes, procs zijn soepel) en vooral return gedrag (een lambda's return verlaat alleen de lambda, terwijl een proc's return de omsluitende methode verlaat — wat verrassend, moeilijk te debuggen gedrag kan veroorzaken).
Het begrijpen van deze onderscheidingen — dat een lambda zich als een methode gedraagt (streng, voorspelbaar, met gelokaliseerde return) terwijl een proc meer soepel is met verrassende return semantiek — is belangrijk voor correct gebruik en voor de veel voorkomende aanbeveling om lambdas de voorkeur te geven vanwege hun voorspelbare, methode-achtige gedrag.
Ondanks dat blocks dagelijkse Ruby zijn en procs/lambdas worden gebruikt voor opslaanbare callbacks en functionele patronen, weerspiegelt het begrijpen van alle drie (vooral de proc-versus-lambda return en argument verschillen) solide Ruby-kennis, helpt je om de proc-return gotcha te vermijden, en is een klassiek interviewonderwerp dat ontwikkelaars onderscheidt die echt begrijpen hoe Ruby code als objecten afhandelt.