Estas son tres formas en que Ruby maneja fragmentos de código como datos. Un block se pasa a un método (no es un objeto); un Proc y una lambda son objetos que envuelven un block (invocables, almacenables). Los Procs y lambdas difieren sutilmente en la verificación de argumentos y el comportamiento de 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 es el código pasado a un método (en { } o do...end) — no es un objeto independiente que puedas almacenar; está vinculado a la llamada del método.
# 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 y lambdas envuelven un block en un objeto que puedes asignar a variables, pasar por ahí y llamar después (.call) — útil para almacenar comportamiento reutilizable.
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 diferencia más importante: una lambda se comporta como un método (argumentos estrictos, return sale solo de la lambda), mientras que un proc es más permisivo (ignora discrepancias de argumentos, y return sale del método envolvente — lo que puede causar comportamiento sorprendente). Las lambdas generalmente son preferidas por su comportamiento predecible, similar al de un método.
Comprender blocks, procs y lambdas — y especialmente sus diferencias — es conocimiento Ruby importante que refleja una comprensión más profunda de cómo Ruby maneja el código como datos. Los Blocks son los más comunes (pasados a métodos para iteración y callbacks — la característica distintiva de Ruby), mientras que los procs y lambdas convierten blocks en objetos almacenables y reutilizables que puedes asignar a variables, pasar por ahí y llamar después (útil para almacenar comportamiento, construir patrones funcionales y pasar callbacks como valores).
Las diferencias clave entre procs y lambdas son sutiles pero importantes y un tema frecuente en entrevistas: verificación de argumentos (las lambdas son estrictas como métodos, los procs son permisivos) y especialmente comportamiento de return (el return de una lambda sale solo de la lambda, mientras que el return de un proc sale del método envolvente — lo que puede causar comportamiento sorprendente y difícil de depurar).
Comprender estas distinciones — que una lambda se comporta como un método (estricta, predecible, con return localizado) mientras que un proc es más permisivo con semántica de return sorprendente — es importante para usarlas correctamente y para la recomendación común de preferir lambdas por su comportamiento predecible y similar al de un método.
Mientras que los blocks son Ruby cotidiano y los procs/lambdas se usan para callbacks almacenables y patrones funcionales, entender los tres (especialmente las diferencias de return y argumentos entre proc y lambda) refleja conocimiento sólido de Ruby, te ayuda a evitar la trampa del return de proc, y es un tema clásico de entrevista que distingue a los desarrolladores que realmente entienden cómo Ruby maneja el código como objetos.