版聊用..

恩这个我知道
举个例子Enumerable#find

def find
 for i in 0...size
  value = self[i] 
  return value if yield(value)#我怎么确定这个return具体跳到哪里
 end
return nil 

评论

25 楼 RednaxelaFX 2009-04-15  

night_stalker 写道

嗯，我想RX的意思就是跳出包着它的 def ~ （lambda 可以看做不写 def 的 def……）我觉得，lambda 和 Proc/block 的行为差异是因为：

• lambda 一般是作为 object 传送
• 而 Proc.new/block 一般是吊尾用的

不管怎样，不写 return 它们就很乖了。

嗯我说得不清楚……嘛，The Ruby Programming Language里讲解iterator的那段特别容易理解，请读一下那个。Programming Ruby扔了吧 =v=

我应该这么说，def...end和lambda {}或者->{}里的return都是返回到它们的调用者的，至于作为block/iterator的Proc里的return，你就把它们看作是它们所在的def...end或者lambda里的return就行了；Ruby里的block/iterator常是配合自定义控制结构来使用的。

24 楼 量产型人型自走炮 2009-04-15  

修正一下理解
只要写了return 除了lambda 总是直接跳出定义他的块所在的具名方法
全局域里面定义的块如果写了return在别的地方调用就肯定出错

这样对吗？

23 楼 night_stalker 2009-04-15  

RednaxelaFX 写道

第二句不对，非lambda的Proc里的return总是返回到return所在的具名方法的外面；你的说法比较含糊……

嗯，我想RX的意思就是跳出包着它的 def ~ （lambda 可以看做不写 def 的 def……）

我觉得，lambda 和 Proc/block 的行为差异是因为：

• lambda 一般是作为 object 传送
• 而 Proc.new/block 一般是吊尾用的

不管怎样，不写 return 它们就很乖了。

22 楼 量产型人型自走炮 2009-04-15  

RednaxelaFX 写道

量产型人型自走炮 写道不写return和lambda作为本地
proc里的return返回直接调用或定义它的函数
这么理解没错吧？Mina~ domo arigato gozaimasu
第一句我不太肯定我的理解跟你的理解是否相同……
第二句不对，非lambda的Proc里的return总是返回到return所在的具名方法的外面；你的说法比较含糊……

总是返回定义它的位置？
那在全局域调用定义的块用了return肯定会出错？

21 楼 RednaxelaFX 2009-04-15  

量产型人型自走炮 写道

咦，这里不是find调用了这个block吗？怎么会作为foo的返回呢？

你看前面我和night_stalker老兄都一直在说是return定义的那个具名方法，不是通过yield或者Proc#call来调用block的方法……

20 楼 量产型人型自走炮 2009-04-15  

引用

不，这是在“全局”作用域里，没有外围函数可返回了……于是就糟糕了。

def foo
  [1, 2, 3].find {|i| return i % 2 == 0 }
end
puts foo

咦，这里不是find调用了这个block吗？怎么会作为foo的返回呢？

19 楼 RednaxelaFX 2009-04-15  

量产型人型自走炮 写道

不写return和lambda作为本地
proc里的return返回直接调用或定义它的函数
这么理解没错吧？Mina~ domo arigato gozaimasu

第一句我不太肯定我的理解跟你的理解是否相同……
第二句不对，非lambda的Proc里的return总是返回到return所在的具名方法的外面；你的说法比较含糊……

18 楼 量产型人型自走炮 2009-04-15  

不写return和lambda作为本地
proc里的return返回直接调用或定义它的函数
这么理解没错吧？
Mina~ domo arigato gozaimasu

17 楼 RednaxelaFX 2009-04-15  

RednaxelaFX 写道

量产型人型自走炮 写道

异常的原因是非本地跳转？这里block里面的return不是作为find的返回吗？不，这是在“全局”作用域里，没有外围函数可返回了……于是就糟糕了。

你要明白这个：

def foo
  [1, 2, 3].find {|i| return i % 2 == 0 }
end

puts foo

与这个：

[1, 2, 3].find {|i| return i % 2 == 0 }

最大的不同就在于return的外面有没有具名方法

16 楼 night_stalker 2009-04-15  

量产型人型自走炮 写道

异常的原因是非本地跳转？这里block里面的return不是作为find的返回吗？

这里是 main 的定义，而不是 find 的定义~

irb(main):016:0> self
=> main

15 楼 量产型人型自走炮 2009-04-15  

哦 返回Bool值了= =这个都有检查啊

14 楼 RednaxelaFX 2009-04-15  

量产型人型自走炮 写道

异常的原因是非本地跳转？这里block里面的return不是作为find的返回吗？

不，这是在“全局”作用域里，没有外围函数可返回了……于是就糟糕了。

13 楼 量产型人型自走炮 2009-04-15  

irb(main):001:0> l = -> i { return i % 2 == 0 }
=> #<Proc:0x1a47c38@(irb):1 (lambda)>
irb(main):002:0> [1, 2, 3].find l
=> #<Enumerator:0x1a45294>
irb(main):003:0> [1, 2, 3].find &l
=> 2
irb(main):004:0> [1, 2, 3].find {|i| return i % 2 == 0 }
LocalJumpError: unexpected return
        from (irb):4:in `block in irb_binding'
        from (irb):4:in `each'
        from (irb):4:in `find'
        from (irb):4
        from E:/build_area/ruby191/bin/irb.bat:20:in `<main>'

异常的原因是非本地跳转？这里block里面的return不是作为find的返回吗？

12 楼 RednaxelaFX 2009-04-15  

量产型人型自走炮 写道

predicate 是对Proc对象的引用吧？那么这里既然不跳出的话 是不是retVal返回的是最后一个偶数？

你说的没错。predicate是一个具有lambda语义的Proc对象，Proc#[]是Proc#call的简写。这里返回的是最后一个偶数。

11 楼 RednaxelaFX 2009-04-15  

上面那个是Ruby 1.9.1里的，而下面用Ruby 1.8.6你会看到行为的差异：

irb(main):001:0> l = lambda {|i| return i % 2 == 0 }
=> #<Proc:0x03528b60@(irb):1>
irb(main):002:0> [1, 2, 3].find l
LocalJumpError: no block given
        from (irb):2:in `find'
        from (irb):2:in `each'
        from (irb):2:in `find'
        from (irb):2
irb(main):003:0> [1, 2, 3].find &l
LocalJumpError: unexpected return
        from (irb):1
        from (irb):3:in `find'
        from (irb):3:in `each'
        from (irb):3:in `find'
        from (irb):3
        from :0
irb(main):004:0> [1, 2, 3].find {|i| return i % 2 == 0 }
LocalJumpError: unexpected return
        from (irb):4
        from (irb):4:in `find'
        from (irb):4:in `each'
        from (irb):4:in `find'
        from (irb):4
        from :0

这里，&后的lambda还是当作普通的block了，所以一样出现了non-local return的问题。Ruby 1.9修改过这个行为……

总之在Ruby里没事别写return是个好习惯 XD

10 楼 量产型人型自走炮 2009-04-15  

Blog引用好糟糕= =

9 楼 量产型人型自走炮 2009-04-15  

RednaxelaFX 写道

你看这个
Ruby代码 module MyEnumerable    def myfind(predicate)      retVal = nil      block = lambda {|e| retVal = e if predicate[e] }      self.myeach block      retVal    end  end    class Foo    include MyEnumerable    def myeach(block)      (1..3).each {|i| block[i] }    end  end    def test    foo = Foo.new    val = foo.myfind lambda {|i| return i % 2 == 0 }    puts val  end    test  module MyEnumerable
  def myfind(predicate)
    retVal = nil
    block = lambda {|e| retVal = e if predicate[e] }
    self.myeach block
    retVal
  end
end

class Foo
  include MyEnumerable
  def myeach(block)
    (1..3).each {|i| block[i] }
  end
end

def test
  foo = Foo.new
  val = foo.myfind lambda {|i| return i % 2 == 0 }
  puts val
end

test

predicate 是对Proc对象的引用吧？
那么这里既然不跳出的话 是不是retVal返回的是最后一个偶数？

8 楼 RednaxelaFX 2009-04-15  

lambda和block都是Proc对象这点或许是一个巨容易让初学者混乱的地方……
Ruby 1.9里有Proc#lambda?来判断一个Proc对象是不是lambda。不过如果你是用yield来调用的话，被调用的肯定是block而不是lambda……看这个：

irb(main):001:0> l = -> i { return i % 2 == 0 }
=> #<Proc:0x1a47c38@(irb):1 (lambda)>
irb(main):002:0> [1, 2, 3].find l
=> #<Enumerator:0x1a45294>
irb(main):003:0> [1, 2, 3].find &l
=> 2
irb(main):004:0> [1, 2, 3].find {|i| return i % 2 == 0 }
LocalJumpError: unexpected return
        from (irb):4:in `block in irb_binding'
        from (irb):4:in `each'
        from (irb):4:in `find'
        from (irb):4
        from E:/build_area/ruby191/bin/irb.bat:20:in `<main>'

7 楼 night_stalker 2009-04-15  

对了，在 lambda 里的 return 和 Proc.new 的 return 不一样。

因为 lambda 是匿名函数，而不是 block。

6 楼 RednaxelaFX 2009-04-15  

你看这个

module MyEnumerable
  def myfind(predicate)
    retVal = nil
    block = lambda {|e| retVal = e if predicate[e] }
    self.myeach block
    retVal
  end
end

class Foo
  include MyEnumerable
  def myeach(block)
    (1..3).each {|i| block[i] }
  end
end

def test
  foo = Foo.new
  val = foo.myfind lambda {|i| return i % 2 == 0 }
  puts val
end

test

诶写得好无聊，不过随便看看吧。
这里虽然test里出现了return，但因为这个return位于一个lambda里，所以是本地返回，所以在调用test的时候不会出现non-local return exception之类的错误。

即使是嵌套了多层的block，return照样是在哪个具名方法里定义就从那个方法返回，只要block不是lambda。像是：

def test
  loop do
    loop do
      loop do
        return '...'
      end
    end
  end
end

puts test