Oto inny sposób, aby to zrozumieć.
Blok to fragment kodu dołączony do wywołania metody na obiekcie. W poniższym przykładzie self jest instancją anonimowej klasy dziedziczącej po ActionView :: Base we frameworku Rails (który sam zawiera wiele modułów pomocniczych). karta to metoda, którą nazywamy siebie. Przekazujemy argument do metody, a następnie zawsze dołączamy blok na końcu wywołania metody:
self.card :contacts do |c|
// a chunk of valid ruby code
end
Ok, więc przekazujemy fragment kodu do metody. Ale jak wykorzystujemy ten blok? Jedną z opcji jest przekonwertowanie fragmentu kodu na obiekt. Ruby oferuje trzy sposoby na przekształcenie fragmentu kodu w obiekt
# 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
W powyższej metodzie & konwertuje blok przekazany do metody na obiekt i zapisuje ten obiekt w bloku zmiennej lokalnej. W rzeczywistości możemy pokazać, że zachowuje się tak samo jak lambda i Proc.new:
def add(&block)
block
end
l3 = add { |a| a + 1 }
l3.call(1)
=> 2
To jest ważne. Kiedy przekazujesz blok do metody i konwertujesz ją za pomocą &, tworzony przez niego obiekt używa Proc.new do wykonania konwersji.
Zauważ, że unikałem użycia "proc" jako opcji. To dlatego, że jest to Ruby 1.8, jest taki sam jak lambda, aw Ruby 1.9 to to samo, co Proc.new i we wszystkich wersjach Rubiego należy tego unikać.
Więc pytasz jaka jest różnica między lambda i Proc.new?
Po pierwsze, jeśli chodzi o przekazywanie parametrów, lambda zachowuje się jak wywołanie metody. Zgłosi wyjątek, jeśli podasz niewłaściwą liczbę argumentów. Natomiast Proc.new zachowuje się jak przypisanie równoległe. Wszystkie nieużywane argumenty są zamieniane na 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 +
Po drugie, lambda i Proc.new inaczej obsługują słowo kluczowe return. Kiedy wykonujesz powrót wewnątrz Proc.new, w rzeczywistości wraca on z metody otaczającej, czyli z otaczającego kontekstu. Kiedy wracasz z bloku lambda, po prostu wraca z bloku, a nie z otaczającej metody. Zasadniczo wychodzi z wywołania do bloku i kontynuuje wykonywanie z resztą otaczającej metody.
> 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"
Skąd więc ta różnica w zachowaniu? Powodem jest to, że dzięki Proc.new możemy używać iteratorów w kontekście otaczających metod i wyciągać logiczne wnioski. Spójrz na ten przykład:
> 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
Oczekujemy, że gdy wywołasz return wewnątrz iteratora, zwróci on z otaczającej metody. Pamiętaj, że bloki przekazywane do iteratorów są konwertowane na obiekty przy użyciu Proc.new i dlatego kiedy używamy return, zakończy on otaczającą metodę.
Możesz myśleć o lambdach jako o metodach anonimowych, izolują one poszczególne bloki kodu w obiekt, który można traktować jak metodę. Ostatecznie pomyśl, że lambda zachowuje się jak anomiczna metoda, a Proc.new zachowuje się jak kod wbudowany.
returnpowraca oświadczenie wprocporównaniulambda.