Aquí hay otra forma de entender esto.
Un bloque es un fragmento de código adjunto a la invocación a una llamada de un método en un objeto. En el ejemplo a continuación, self es una instancia de una clase anónima que hereda de ActionView :: Base en el marco de Rails (que a su vez incluye muchos módulos auxiliares). La tarjeta es un método que llamamos a uno mismo. Pasamos un argumento al método y luego adjuntamos siempre el bloque al final de la invocación del método:
self.card :contacts do |c|
// a chunk of valid ruby code
end
Ok, entonces estamos pasando una porción de código a un método. Pero, ¿cómo hacemos uso de este bloque? Una opción es convertir el fragmento de código en un objeto. Ruby ofrece tres formas de convertir un fragmento de código en un objeto
# lambda
> l = lambda { |a| a + 1 }
> l.call(1)
=> 2
# Proc.new
> l2= Proc.new { |a| a + 1 }
> l2.call(1)
=> 2
# & as the last method argument with a local variable name
def add(&block)
end
En el método anterior, el & convierte el bloque pasado al método en un objeto y almacena ese objeto en el bloque de variable local. De hecho, podemos mostrar que tiene el mismo comportamiento que lambda y Proc.new:
def add(&block)
block
end
l3 = add { |a| a + 1 }
l3.call(1)
=> 2
Esto es importante. Cuando pasa un bloque a un método y lo convierte usando &, el objeto que crea usa Proc.new para realizar la conversión.
Tenga en cuenta que evité el uso de "proc" como una opción. Eso es porque es Ruby 1.8, es lo mismo que lambda y en Ruby 1.9, es lo mismo que Proc.new y en todas las versiones de Ruby se debe evitar.
Entonces, ¿cuál es la diferencia entre lambda y Proc.new?
Primero, en términos de paso de parámetros, lambda se comporta como una llamada a un método. Planteará una excepción si pasa el número incorrecto de argumentos. Por el contrario, Proc.new se comporta como una asignación paralela. Todos los argumentos no utilizados se convierten en nulo:
> l = lambda {|a,b| puts "#{a} + #{b}" }
=> #<Proc:0x007fbffcb47e40@(irb):19 (lambda)>
> l.call(1)
ArgumentError: wrong number of arguments (1 for 2)
> l2 = Proc.new {|a,b| puts "#{a} + #{b}" }
=> #<Proc:0x007fbffcb261a0@(irb):21>
> l2.call(1)
1 +
En segundo lugar, lambda y Proc.new manejan la palabra clave return de manera diferente. Cuando realiza un retorno dentro de Proc.new, en realidad regresa del método de inclusión, es decir, el contexto circundante. Cuando regresa de un bloque lambda, simplemente regresa del bloque, no del método de cierre. Básicamente, sale de la llamada al bloque y continúa la ejecución con el resto del método de cierre.
> def add(a,b)
l = Proc.new { return a + b}
l.call
puts "now exiting method"
end
> add(1,1)
=> 2 # NOTICE it never prints the message "now exiting method"
> def add(a,b)
l = lambda { return a + b }
l.call
puts "now exiting method"
end
> add(1,1)
=> now exiting method # NOTICE this time it prints the message "now exiting method"
Entonces, ¿por qué esta diferencia de comportamiento? La razón es porque con Proc.new, podemos usar iteradores dentro del contexto de los métodos de cierre y sacar conclusiones lógicas. Mira este ejemplo:
> def print(max)
[1,2,3,4,5].each do |val|
puts val
return if val > max
end
end
> print(3)
1
2
3
4
Esperamos que cuando invoquemos return dentro del iterador, regrese del método de cierre. Recuerde que los bloques pasados a los iteradores se convierten en objetos usando Proc.new y es por eso que cuando usamos return, saldrá del método de cierre.
Puede pensar en lambdas como métodos anónimos, que aíslan bloques de código individuales en un objeto que se puede tratar como un método. En última instancia, piense que una lambda se comporta como un método anónimo y que Proc.new se comporta como un código en línea.
returndeclaración devuelve enprocversuslambda.