Dette er tre måter Ruby håndterer kodebiter som data. En block sendes til en metode (ikke et objekt); en Proc og en lambda er objekter som pakker inn en block (callable, lagringsbara). Procs og lambdas har små forskjeller i argumentsjekking og return-atferd.
[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
En block er koden som sendes til en metode (i { } eller do...end) — det er ikke et eget objekt du kan lagre; det er knyttet til metodekallet.
# 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 pakker inn en block i et objekt du kan tilordne til variabler, sende omkring, og kalle senere (.call) — nyttig for å lagre gjenbrukbar atferd.
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 viktigste forskjellen: en lambda oppfører seg som en metode (strenge argumenter, return avslutter bare lambdaen), mens en proc er mer slapt (ignorerer argumentfeil, og return avslutter den omgivende metoden — som kan forårsake overraskende oppførsel). Lambdas foretrekkes generelt for sin metodelignende, forutsigbare atferd.
Å forstå blocks, procs og lambdas — og spesielt deres forskjeller — er viktig Ruby-kunnskap som gjenspeiler dypere forståelse av hvordan Ruby håndterer kode som data. Blocks er mest vanlige (sendt til metoder for iterasjon og callbacks — Rubys kjennetegn), mens procs og lambdas gjør blocks til lagringbare, gjenbrukbare objekter du kan tilordne til variabler, sende omkring, og kalle senere (nyttig for å lagre atferd, bygge funksjonelle mønstre, og sende callbacks som verdier).
Hovedforskjellene mellom procs og lambdas er subtile men viktige og et vanlig intervjuemne: argumentsjekking (lambdas er streng som metoder, procs er slappe) og spesielt return-atferd (en lambdas return avslutter bare lambdaen, mens en procs return avslutter den omgivende metoden — som kan forårsake overraskende, vanskelig å debugge atferd).
Å forstå disse distinksjoner — at en lambda oppfører seg som en metode (streng, forutsigbar, med lokalisert return) mens en proc er mer slapt med overraskende return-semantikk — er viktig for å bruke dem korrekt og for den vanlige anbefalingen om å foretrekke lambdas for deres forutsigbare, metodelignende atferd.
Mens blocks er daglig Ruby og procs/lambdas brukes til lagringbare callbacks og funksjonelle mønstre, å forstå alle tre (spesielt proc-vs-lambda return og argumentforskjellene) reflekterer solid Ruby-kunnskap, hjelper deg å unngå proc-return-gotchaen, og er et klassisk intervjuemne som skiller utviklere som virkelig forstår Rubys håndtering av kode som objekter.