Voici une autre façon de comprendre cela.
Un bloc est un morceau de code attaché à l'appel à un appel d'une méthode sur un objet. Dans l'exemple ci-dessous, self est une instance d'une classe anonyme héritant d'ActionView :: Base dans le framework Rails (qui lui-même comprend de nombreux modules d'assistance). la carte est une méthode que nous appelons nous-mêmes. Nous passons un argument à la méthode puis nous attachons toujours le bloc à la fin de l'appel de la méthode:
self.card :contacts do |c|
// a chunk of valid ruby code
end
Ok, donc nous passons un morceau de code à une méthode. Mais comment utiliser ce bloc? Une option consiste à convertir le morceau de code en un objet. Ruby propose trois façons de convertir un morceau de code en objet
# 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
Dans la méthode ci-dessus, le & convertit le bloc passé à la méthode en un objet et stocke cet objet dans le bloc de variables locales. En fait, nous pouvons montrer qu'il a le même comportement que lambda et Proc.new:
def add(&block)
block
end
l3 = add { |a| a + 1 }
l3.call(1)
=> 2
C'est important. Lorsque vous passez un bloc à une méthode et que vous le convertissez à l'aide de &, l'objet qu'il crée utilise Proc.new pour effectuer la conversion.
Notez que j'ai évité d'utiliser "proc" comme option. C'est parce que c'est Ruby 1.8, c'est la même chose que lambda et dans Ruby 1.9, c'est la même chose que Proc.new et dans toutes les versions de Ruby, cela devrait être évité.
Alors vous demandez quelle est la différence entre lambda et Proc.new?
Premièrement, en termes de passage de paramètres, lambda se comporte comme un appel de méthode. Cela lèvera une exception si vous passez le mauvais nombre d'arguments. En revanche, Proc.new se comporte comme une affectation parallèle. Tous les arguments inutilisés sont convertis en nil:
> 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 +
Deuxièmement, lambda et Proc.new gèrent le mot clé return différemment. Lorsque vous effectuez un retour à l'intérieur de Proc.new, il retourne en fait à partir de la méthode englobante, c'est-à-dire du contexte environnant. Lorsque vous revenez d'un bloc lambda, il revient simplement du bloc, pas de la méthode englobante. Fondamentalement, il quitte l'appel au bloc et continue l'exécution avec le reste de la méthode englobante.
> 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"
Alors pourquoi cette différence de comportement? La raison en est qu'avec Proc.new, nous pouvons utiliser des itérateurs dans le contexte des méthodes englobantes et tirer des conclusions logiques. Regardez cet exemple:
> 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
Nous nous attendons à ce que lorsque nous invoquons return à l'intérieur de l'itérateur, il revienne de la méthode englobante. N'oubliez pas que les blocs passés aux itérateurs sont convertis en objets à l'aide de Proc.new et c'est pourquoi lorsque nous utilisons return, il quittera la méthode englobante.
Vous pouvez considérer les lambdas comme des méthodes anonymes, elles isolent des blocs de code individuels dans un objet qui peut être traité comme une méthode. En fin de compte, pensez qu'un lambda se comporte comme une méthode anomyous et que Proc.new se comporte comme du code en ligne.
returndéclaration renvoie de parprocrapport àlambda.