Ось ще один спосіб зрозуміти це.
Блок - це фрагмент коду, приєднаний до виклику до виклику методу на об'єкті. У наведеному нижче прикладі self - це екземпляр анонімного класу, успадкованого від ActionView :: Base в рамках Rails (який сам включає багато допоміжних модулів). картка - це метод, який ми закликаємо до себе. Ми передаємо аргумент методу, а потім завжди прикріплюємо блок до кінця виклику методу:
self.card :contacts do |c|
// a chunk of valid ruby code
end
Гаразд, тому ми передаємо шматок коду методу. Але як ми можемо використовувати цей блок? Один із варіантів - перетворити фрагмент коду в об'єкт. Рубі пропонує три способи перетворення фрагмента коду в об'єкт
# 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
У вищеописаному методі & перетворює переданий блок методу в об'єкт і зберігає цей об'єкт у локальному блоці змінної. Насправді ми можемо показати, що вона має таку саму поведінку, як лямбда та Proc.new:
def add(&block)
block
end
l3 = add { |a| a + 1 }
l3.call(1)
=> 2
Це ВАЖЛИВО. Коли ви передаєте блок методу та перетворюєте його за допомогою &, об'єкт, який він створює, використовує Proc.new для перетворення.
Зауважте, що я уникав використання "proc" як опції. Це тому, що це Ruby 1.8, це те саме, що і лямбда, а у Ruby 1.9 - це те саме, що і Proc.new, і у всіх версіях Ruby цього слід уникати.
Тоді ви запитаєте, в чому різниця між лямбда і Proc.new?
По-перше, що стосується передачі параметрів, лямбда поводиться як виклик методу. Це призведе до виключення, якщо ви передасте неправильну кількість аргументів. Навпаки, Proc.new поводиться як паралельне призначення. Усі невикористані аргументи перетворюються на нуль:
> 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 +
По-друге, лямбда та Proc.new по-різному обробляють ключове слово повернення. Коли ви робите повернення всередину Proc.new, воно фактично повертається із методу, що додає, тобто оточуючого контексту. Коли ви повертаєтесь з лямбда-блоку, він просто повертається з блоку, а не методу укладання. В основному, він виходить з виклику до блоку і продовжує виконання з рештою способу, що додає.
> 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"
То чому ця поведінкова різниця? Причина полягає в тому, що за допомогою Proc.new ми можемо використовувати ітератори всередині контексту методів, що складаються укладаючи, та робити логічні висновки. Подивіться на цей приклад:
> 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
Ми очікуємо, що коли ми будемо викликати повернення всередині ітератора, він повернеться із методу, що додає. Пам'ятайте, що блоки, передані ітераторам, перетворюються на об'єкти за допомогою Proc.new, і саме тому, коли ми будемо використовувати return, він вийде з методу укладання.
Ви можете вважати лямбдаси як анонімні методи, вони виділяють окремі блоки коду в об’єкт, який можна розглядати як метод. Зрештою, подумайте про лямбду як про аномічний метод, а Proc.new поводиться як вбудований код.
returnповертається твердженняprocпротиlambda.