简单的回答:重要的是返回的作用:lambda返回自身，proc返回自身和调用它的函数。

不太清楚的是为什么要使用它们。Lambda是我们在函数式编程中所期望的。它基本上是一个匿名方法，当前范围自动绑定。这两个中，应该用的是。

另一方面，Proc对于实现语言本身非常有用。例如，你可以用它们实现“if”语句或“For”循环。在proc中找到的任何返回都将从调用它的方法中返回，而不仅仅是if语句。这就是语言的工作方式，if语句的工作方式，所以我猜Ruby在幕后使用了它，他们只是因为它看起来很强大而公开它。

只有当你创建新的语言结构，如循环，if-else结构等，你才真正需要这个。

一个很好的方法是，lambdas是在它们自己的作用域内执行的(就好像它是一个方法调用一样)，而Procs可以被看作是与调用方法内联执行的，至少这是决定在每种情况下使用哪一个的好方法。

Ruby中的闭包很好地概述了块、lambda和proc在Ruby中的工作方式。

我找到了这个页面，它展示了Proc.new和lambda之间的区别。根据该页面，唯一的区别是lambda严格限制它接受的参数数量，而Proc.new将缺失的参数转换为nil。下面是一个IRB会话示例，说明了两者的区别:

irb(main):001:0> l = lambda { |x, y| x + y }
=> #<Proc:0x00007fc605ec0748@(irb):1>
irb(main):002:0> p = Proc.new { |x, y| x + y }
=> #<Proc:0x00007fc605ea8698@(irb):2>
irb(main):003:0> l.call "hello", "world"
=> "helloworld"
irb(main):004:0> p.call "hello", "world"
=> "helloworld"
irb(main):005:0> l.call "hello"
ArgumentError: wrong number of arguments (1 for 2)
    from (irb):1
    from (irb):5:in `call'
    from (irb):5
    from :0
irb(main):006:0> p.call "hello"
TypeError: can't convert nil into String
    from (irb):2:in `+'
    from (irb):2
    from (irb):6:in `call'
    from (irb):6
    from :0

该页面还建议使用lambda，除非您特别想要容错行为。我同意这种观点。使用lambda似乎更简洁一点，而且差异如此微不足道，在一般情况下，它似乎是更好的选择。

至于Ruby 1.9，抱歉，我还没有研究过1.9，但我不认为他们会有那么大的变化(不过不要相信我的话，似乎你已经听说了一些变化，所以我可能错了)。

我不能说太多细微的差别。但是，我可以指出Ruby 1.9现在允许lambdas和block的可选参数。

下面是1.9版本中stabby lambdas的新语法:

stabby = ->(msg='inside the stabby lambda') { puts msg }

Ruby 1.8没有这种语法。声明blocks/lambdas的传统方式也不支持可选参数:

# under 1.8
l = lambda { |msg = 'inside the stabby lambda'|  puts msg }
SyntaxError: compile error
(irb):1: syntax error, unexpected '=', expecting tCOLON2 or '[' or '.'
l = lambda { |msg = 'inside the stabby lambda'|  puts msg }

然而，Ruby 1.9支持可选参数，即使使用旧语法:

l = lambda { |msg = 'inside the regular lambda'|  puts msg }
#=> #<Proc:0x0e5dbc@(irb):1 (lambda)>
l.call
#=> inside the regular lambda
l.call('jeez')
#=> jeez

如果你想为Leopard或Linux构建Ruby1.9，看看这篇文章(无耻的自我推销)。

Lambda按预期工作，就像其他语言一样。

有线Proc.new令人惊讶和困惑。

proc .new创建的proc中的return语句不仅会返回自身的控制，还会返回包含它的方法的控制。

def some_method
  myproc = Proc.new {return "End."}
  myproc.call

  # Any code below will not get executed!
  # ...
end

你可以认为Proc.new将代码插入到封闭方法中，就像block一样。 但是Proc.new创建的是一个对象，而block是对象的一部分。

lambda和Proc.new之间还有另一个区别，那就是它们对(错误)参数的处理。 lambda会抱怨它，而Proc.new会忽略额外的参数或将没有参数视为nil。

irb(main):021:0> l = -> (x) { x.to_s }
=> #<Proc:0x8b63750@(irb):21 (lambda)>
irb(main):022:0> p = Proc.new { |x| x.to_s}
=> #<Proc:0x8b59494@(irb):22>
irb(main):025:0> l.call
ArgumentError: wrong number of arguments (0 for 1)
        from (irb):21:in `block in irb_binding'
        from (irb):25:in `call'
        from (irb):25
        from /usr/bin/irb:11:in `<main>'
irb(main):026:0> p.call
=> ""
irb(main):049:0> l.call 1, 2
ArgumentError: wrong number of arguments (2 for 1)
        from (irb):47:in `block in irb_binding'
        from (irb):49:in `call'
        from (irb):49
        from /usr/bin/irb:11:in `<main>'
irb(main):050:0> p.call 1, 2
=> "1"

顺便说一句，在Ruby 1.8中，proc创建了一个lambda，而在Ruby 1.9+中，它的行为就像proc .new，这真的很令人困惑。