Questi sono tre modi in cui Ruby gestisce chunk di codice come dati. Un block viene passato a un metodo (non è un oggetto); un Proc e un lambda sono oggetti che avvolgono un block (callable, memorizzabili). Proc e lambda differiscono sottilmente nel controllo degli argomenti e nel comportamento di 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
Un block è il codice passato a un metodo (in { } o do...end) — non è un oggetto standalone che puoi memorizzare; è legato alla chiamata del metodo.
# 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
Proc e lambda avvolgono un block in un oggetto che puoi assegnare a variabili, passare in giro e chiamare successivamente (.call) — utile per memorizzare comportamenti riutilizzabili.
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
La differenza più importante: un lambda si comporta come un metodo (argomenti rigorosi, return esce solo dal lambda), mentre un proc è più permissivo (ignora gli argomenti mancanti, e return esce dal metodo circostante — che può causare comportamenti sorprendenti). I lambda sono generalmente preferiti per il loro comportamento prevedibile, simile a un metodo.
Comprendere block, proc e lambda — e soprattutto le loro differenze — è una conoscenza importante di Ruby che riflette una comprensione più profonda di come Ruby gestisce il codice come dati. I block sono i più comuni (passati ai metodi per iterazione e callback — la caratteristica distintiva di Ruby), mentre proc e lambda trasformano i block in oggetti memorizzabili e riutilizzabili che puoi assegnare a variabili, passare in giro e chiamare successivamente (utili per memorizzare il comportamento, costruire pattern funzionali e passare callback come valori).
Le differenze chiave tra proc e lambda sono sottili ma importanti e un argomento frequente nelle interviste: controllo degli argomenti (lambda sono rigorosi come i metodi, proc sono permissivi) e soprattutto comportamento di return (il return di un lambda esce solo dal lambda, mentre il return di un proc esce dal metodo circostante — che può causare comportamenti sorprendenti e difficili da debuggare).
Comprendere queste distinzioni — che un lambda si comporta come un metodo (rigoroso, prevedibile, con return localizzato) mentre un proc è più permissivo con semantica di return sorprendente — è importante per utilizzarli correttamente e per la raccomandazione comune di preferire lambda per il loro comportamento prevedibile e simile a un metodo.
Mentre i block sono Ruby quotidiano e proc/lambda vengono utilizzati per callback memorizzabili e pattern funzionali, comprendere tutti e tre (soprattutto le differenze di return e argomenti tra proc e lambda) riflette una conoscenza solida di Ruby, ti aiuta a evitare il gotcha di proc-return e è un argomento classico di intervista che distingue gli sviluppatori che veramente comprendono il modo in cui Ruby gestisce il codice come oggetti.