В чем разница между процедурой и лямбдой в Ruby?

Question

И когда бы вы использовали один, а не другой?

Answer 1

Одно из различий заключается в том, как они обрабатывают аргументы. Создание процедуры с использованием proc {} а также Proc.new {} эквивалентны. Однако, используя lambda {} дает вам прок, который проверяет количество аргументов, переданных ему. От ri Kernel#lambda:

Эквивалент Proc.new, за исключением того, что полученные объекты Proc проверяют количество параметров, переданных при вызове.

Пример:

p = Proc.new {|a, b| puts a**2+b**2 } # => #<Proc:0x3c7d28@(irb):1>
p.call 1, 2 # => 5
p.call 1 # => NoMethodError: undefined method `**' for nil:NilClass
p.call 1, 2, 3 # => 5
l = lambda {|a, b| puts a**2+b**2 } # => #<Proc:0x15016c@(irb):5 (lambda)>
l.call 1, 2 # => 5
l.call 1 # => ArgumentError: wrong number of arguments (1 for 2)
l.call 1, 2, 3 # => ArgumentError: wrong number of arguments (3 for 2)

Кроме того, как указывает Кен, используя return внутри лямбда возвращает значение этого лямбда, но с использованием return в процедуре возвращается из вмещающего блока.

lambda { return :foo }.call # => :foo
return # => LocalJumpError: unexpected return
Proc.new { return :foo }.call # => LocalJumpError: unexpected return

Так что для большинства быстрых применений они одинаковы, но если вы хотите автоматическую строгую проверку аргументов (которая иногда может также помочь с отладкой), или если вам нужно использовать return заявление, чтобы вернуть значение proc, используйте lambda,

Answer 2

Реальная разница между процессами и лямбдами связана с ключевыми словами потока управления. Я говорю о return, raise, break, redo, retry и т.д. - эти контрольные слова. Допустим, у вас есть инструкция возврата в процедуре. Когда вы вызываете ваш proc, он не только выкинет вас из него, но и вернет метод включения, например:

def my_method
  puts "before proc"
  my_proc = Proc.new do
    puts "inside proc"
    return
  end
  my_proc.call
  puts "after proc"
end

my_method

shoaib@shoaib-ubuntu-vm:~/tmp$ ruby a.rb
before proc
inside proc

Финал puts в методе, никогда не выполнялся, так как, когда мы вызывали нашу процедуру, return внутри нас выкинули нас из метода. Однако, если мы конвертируем наш proc в лямбду, мы получаем следующее:

def my_method
  puts "before proc"
  my_proc = lambda do
    puts "inside proc"
    return
  end
  my_proc.call
  puts "after proc"
end

my_method
shoaib@shoaib-ubuntu-vm:~/tmp$ ruby a.rb
before proc
inside proc
after proc

Возвращение внутри лямбды только выводит нас из самой лямбды, и метод включения продолжает выполняться. То, как ключевые слова потока управления обрабатываются внутри процедур и лямбда-выражений, является основным отличием между ними

Answer 3

Есть только два основных отличия.

• Первый lambda проверяет количество аргументов, переданных ему, а proc не. Это означает, что lambda выдаст ошибку, если вы передадите ей неверное количество аргументов, тогда как proc будет игнорировать неожиданные аргументы и назначать nil к любому, что отсутствует.
• Во-вторых, когда lambda возвращает, передает управление обратно вызывающему методу; когда proc возвращает, он делает это немедленно, не возвращаясь к вызывающему методу.

Чтобы увидеть, как это работает, взгляните на код ниже. Наш первый метод вызывает proc; второй вызывает lambda,

def batman_ironman_proc
  victor = Proc.new { return "Batman will win!" }
  victor.call
  "Iron Man will win!"
end

puts batman_ironman_proc # prints "Batman will win!"

def batman_ironman_lambda
  victor = lambda { return "Batman will win!" }
  victor.call
  "Iron Man will win!"
end

puts batman_ironman_lambda # prints "Iron Man will win!"

Посмотрите, как proc говорит "Бэтмен победит!", это потому, что он возвращается немедленно, не возвращаясь к методу batman_ironman_proc.

наш lambdaоднако после вызова возвращается к методу, поэтому метод возвращает последний код, который он оценивает: "Железный человек победит!"

Answer 4

# Proc Примеры

p = Proc.new { |x| puts x*2 }
[1,2,3].each(&p)              # The '&' tells ruby to turn the proc into a block 

proc = Proc.new { puts "Hello World" }
proc.call

# Лямбда Примеры

lam = lambda { |x| puts x*2 }
[1,2,3].each(&lam)

lam = lambda { puts "Hello World" }
lam.call           

Различия между процами и лямбдами

Прежде чем перейти к различиям между процессами и лямбдами, важно отметить, что они оба являются объектами Proc.

proc = Proc.new { puts "Hello world" }
lam = lambda { puts "Hello World" }

proc.class # returns 'Proc'
lam.class  # returns 'Proc'

Однако лямбды - это другой "вкус" проков. Эта небольшая разница проявляется при возврате предметов.

proc   # returns '#<Proc:0x007f96b1032d30@(irb):75>'
lam    # returns '<Proc:0x007f96b1b41938@(irb):76 (lambda)>'

1. Лямбды проверяют количество аргументов, а проки не

lam = lambda { |x| puts x }    # creates a lambda that takes 1 argument
lam.call(2)                    # prints out 2
lam.call                       # ArgumentError: wrong number of arguments (0 for 1)
lam.call(1,2,3)                # ArgumentError: wrong number of arguments (3 for 1)

Напротив, процессорам все равно, если им передано неправильное количество аргументов.

proc = Proc.new { |x| puts x } # creates a proc that takes 1 argument
proc.call(2)                   # prints out 2
proc.call                      # returns nil
proc.call(1,2,3)               # prints out 1 and forgets about the extra arguments

2. Lambdas и procs по-разному обрабатывают ключевое слово return

'return' внутри лямбда-кода запускает код прямо за пределами лямбда-кода

def lambda_test
  lam = lambda { return }
  lam.call
  puts "Hello world"
end

lambda_test                 # calling lambda_test prints 'Hello World'

'return' внутри proc вызывает код вне метода, в котором выполняется proc

def proc_test
  proc = Proc.new { return }
  proc.call
  puts "Hello world"
end

proc_test                 # calling proc_test prints nothing

И чтобы ответить на ваш другой запрос, какой использовать и когда? Я буду следовать за @jtbandes, как он упомянул

Так что для большинства быстрых применений они одинаковы, но если вам нужна автоматическая строгая проверка аргументов (которая иногда может также помочь с отладкой), или если вам нужно использовать инструкцию return для возврата значения proc, используйте lambda.

Первоначально опубликовано здесь

Answer 5

Вообще говоря, лямбды более интуитивны, чем проки, потому что они больше похожи на методы. Они довольно строги в отношении арности и просто выходят, когда вы вызываете return. По этой причине многие Rubyists используют лямбды в качестве первого выбора, если они не нуждаются в специфических особенностях процедур.

Procs: объекты класса Proc, Как и блоки, они оцениваются в области, в которой они определены.Лямбды: также объекты класса Proc но немного отличается от обычных процедур. Это замыкания, подобные блокам и процессам, и поэтому они оцениваются в области, в которой они определены.

Создание Proc

a = Proc.new { |x| x 2 }

Создание лямбды

b = lambda { |x| x 2 }

Answer 6

Это несколько тонко. Оба эти метода создают замыкания и оба возвращают объекты Proc. Там на самом деле и третий путь - Proc.new, Разница заключается в том, как они ведут себя, и специфика зависит от того, используете ли вы Ruby 1.8 или 1.9 (на самом деле, есть еще один способ их создания в Ruby 1.9). В общем случае, это не то, о чем вам нужно беспокоиться. Только когда вы беспокоитесь о строгости, это имеет значение. Когда использовать лямбду, когда использовать Proc.new? покрывает различия довольно хорошо.

Answer 7

Вот еще один способ понять это.

Блок - это фрагмент кода, прикрепленный к вызову метода объекта. В приведенном ниже примере self является экземпляром анонимного класса, унаследованного от ActionView::Base в платформе Rails (который сам включает в себя множество вспомогательных модулей). карта - это метод, который мы называем собой. Мы передаем аргумент методу, а затем всегда присоединяем блок к концу вызова метода:

self.card :contacts do |c|
  // a chunk of valid ruby code    
end

Итак, мы передаем кусок кода методу. Но как мы используем этот блок? Один из вариантов - преобразовать кусок кода в объект. Ruby предлагает три способа конвертировать кусок кода в объект

# 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 + 

Во-вторых, lambda и Proc.new по-разному обрабатывают ключевое слово return. Когда вы делаете возврат внутри 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

Мы ожидаем, что когда мы вызовем return внутри итератора, он вернется из включающего метода. Помните, что блоки, переданные итераторам, преобразуются в объекты с помощью Proc.new, и поэтому, когда мы используем return, он выходит из метода включения.

Вы можете думать о лямбдах как об анонимных методах, они изолируют отдельные блоки кода в объект, который можно рассматривать как метод. В конечном счете, думайте, что лямбда ведет себя как аномный метод, а Proc.new ведет себя как встроенный код.

Answer 8

Полезный пост на рубиновых путеводителях: блоки, процы и лямбды

Procs возвращаются из текущего метода, в то время как лямбды возвращаются из самой лямбды.

Procs не заботится о правильном количестве аргументов, в то время как лямбды вызовут исключение.

Answer 9

Различия между proc и lambda в том, что proc - это просто копия кода с заменяемыми аргументами по очереди, тогда как lambda - это функция, как и в других языках. (поведение возврата, проверка аргументов)