Aqui está outra maneira de entender isso.
Um bloco é um pedaço de código anexado à chamada para uma chamada de um método em um objeto. No exemplo abaixo, self é uma instância de uma classe anônima herdada de ActionView :: Base na estrutura do Rails (que inclui muitos módulos auxiliares). cartão é um método que chamamos de auto. Passamos um argumento para o método e sempre anexamos o bloco ao final da invocação do método:
self.card :contacts do |c|
// a chunk of valid ruby code
end
Ok, estamos passando um pedaço de código para um método. Mas como usamos esse bloco? Uma opção é converter o pedaço de código em um objeto. Ruby oferece três maneiras de converter um pedaço de código em um 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
No método acima, o & converte o bloco passado para o método em um objeto e armazena esse objeto no bloco variável local. De fato, podemos mostrar que ele tem o mesmo comportamento que o lambda e o Proc.new:
def add(&block)
block
end
l3 = add { |a| a + 1 }
l3.call(1)
=> 2
Isso é importante. Quando você passa um bloco para um método e o converte usando &, o objeto que ele cria usa Proc.new para fazer a conversão.
Observe que eu evitei o uso de "proc" como uma opção. Isso porque Ruby 1.8, é o mesmo que lambda e no Ruby 1.9, é o mesmo que Proc.new e em todas as versões do Ruby deve ser evitado.
Então você pergunta qual é a diferença entre lambda e Proc.new?
Primeiro, em termos de passagem de parâmetro, o lambda se comporta como uma chamada de método. Irá gerar uma exceção se você passar o número errado de argumentos. Por outro lado, o Proc.new se comporta como atribuição paralela. Todos os argumentos não utilizados são convertidos em zero:
> 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 +
Segundo, lambda e Proc.new tratam a palavra-chave return de maneira diferente. Quando você faz um retorno dentro do Proc.new, ele realmente retorna do método anexo, ou seja, do contexto circundante. Quando você retorna de um bloco lambda, ele apenas retorna do bloco, não do método envolvente. Basicamente, ele sai da chamada para o bloco e continua a execução com o restante do método anexo.
> 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"
Então, por que essa diferença comportamental? O motivo é que, com o Proc.new, podemos usar iteradores dentro do contexto de métodos anexos e tirar conclusões lógicas. Veja este exemplo:
> 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, quando invocarmos o retorno dentro do iterador, ele retornará do método envolvente. Lembre-se de que os blocos passados para os iteradores são convertidos em objetos usando Proc.new e é por isso que quando usamos return, ele sai do método envolvente.
Você pode pensar em lambdas como métodos anônimos, eles isolam blocos individuais de código em um objeto que pode ser tratado como um método. Por fim, pense em um lambda se comportando como um método anômalo e Proc.novo se comportando como código embutido.
returnretorno da declaração emprocversuslambda.