Disse er tre måder, Ruby håndterer stykker af kode som data. Et block bliver passed til en metode (ikke et objekt); en Proc og en lambda er objekter, der wrapper et block (callable, opbevarelig). Procs og lambdas adskiller sig subtilt i argumentkontrol og return-adfærd.
[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
Et block er koden, der passes til en metode (i { } eller do...end) — det er ikke et selvstændigt objekt, du kan opbevare; det er bundet til metodekalddet.
# 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 og lambdas wrapper et block til et objekt, du kan tildele til variabler, passere rundt og kalde senere (.call) — nyttigt til at opbevare genbrugelig adfærd.
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 vigtigste forskel: en lambda opfører sig som en metode (strenge argumenter, return afslutter kun lambdaen), mens en proc er mere lenient (ignorerer argumentuoverensstemmelser, og return afslutter den omsluttende metode — hvilket kan forårsage overraskende adfærd). Lambdas foretrækkes generelt for deres metodelignende, forudsigelige adfærd.
At forstå blocks, procs og lambdas — og især deres forskelle — er vigtig Ruby-viden, der afspejler dybere forståelse af, hvordan Ruby håndterer kode som data. Blocks er de mest almindelige (passed til metoder for iteration og callbacks — Rubys signaturfunktion), mens procs og lambdas omdanner blocks til opbevarelige, genbrugelige objekter, du kan tildele til variabler, passere rundt og kalde senere (nyttigt til at opbevare adfærd, bygge funktionelle mønstre og passere callbacks som værdier).
De vigtigste forskelle mellem procs og lambdas er subtile men vigtige og et hyppigt interviewemne: argumentkontrol (lambdas er strenge som metoder, procs er lenlente) og især return-adfærd (en lambdas return afslutter kun lambdaen, mens en procs return afslutter den omsluttende metode — hvilket kan forårsage overraskende, svær-at-debugge adfærd).
At forstå disse distinktioner — at en lambda opfører sig som en metode (streng, forudsigelig, med lokaliseret return) mens en proc er mere lenient med overraskende return-semantik — er vigtig for at bruge dem korrekt og for den almindelige anbefaling til at foretrække lambdas for deres forudsigelige, metodelignende adfærd.
Mens blocks er daglig Ruby og procs/lambdas bruges til opbevarelige callbacks og funktionelle mønstre, afspejler forståelse af alle tre (især proc-vs-lambda return og argument-forskellene) solid Ruby-viden, hjælper dig med at undgå proc-return-gotchaen og er et klassisk interviewemne, der adskiller udvikler, der virkelig forstår Rubys håndtering af kode som objekter.