方法中可以有方法吗？

Question

我在方法中有一个方法。内部方法取决于正在运行的变量循环。这是个坏主意吗？

Answer 1

更新：由于这个答案最近似乎引起了一些兴趣，我想指出有discussion on the Ruby issue tracker to remove the feature discussed here, namely to forbid having method definitions inside a method body。

---

不，Ruby 没有嵌套方法。

你可以这样做：

class Test1
  def meth1
    def meth2
      puts "Yay"
    end
    meth2
  end
end

Test1.new.meth1

但这不是嵌套方法。我再说一遍：Ruby 没有嵌套方法。

这是一个动态方法定义。当你运行meth1 时，meth1 的主体将被执行。正文恰好定义了一个名为meth2的方法，这就是为什么在运行一次meth1之后，你可以调用meth2。

但是meth2 是在哪里定义的？好吧，很明显它没有定义为嵌套方法，因为在 Ruby 中没有嵌套方法。定义为Test1的实例方法：

Test1.new.meth2
# Yay

另外，显然每次运行meth1时都会重新定义：

Test1.new.meth1
# Yay

Test1.new.meth1
# test1.rb:3: warning: method redefined; discarding old meth2
# test1.rb:3: warning: previous definition of meth2 was here
# Yay

简而言之：不，Ruby 不支持嵌套方法。

还要注意，在 Ruby 中，方法体不能是闭包，只有块体可以。这几乎消除了嵌套方法的主要用例，因为即使 if Ruby 支持嵌套方法，您也不能在嵌套方法中使用外部方法的变量。

---

更新继续：然后，在 稍后 阶段，此语法可能会被重新用于向 Ruby 添加嵌套方法，其行为方式与我描述的一样：它们将被限定为它们的包含方法，即在其包含方法体之外不可见且不可访问。并且可能，他们可以访问其包含方法的词法范围。但是，如果您阅读我上面链接的讨论，您可以观察到 matz 严重反对嵌套方法（但仍用于删除嵌套方法定义）。

Answer 2

其实是可以的。您可以为此使用 procs/lambda。

def test(value)
  inner = ->() {
    value * value
  }
  inner.call()
end

Answer 3

不，不，Ruby 确实有嵌套方法。检查这个：

def outer_method(arg)
    outer_variable = "y"
    inner_method = lambda {
      puts arg
      puts outer_variable
    }
    inner_method[]
end

outer_method "x" # prints "x", "y"

Answer 4

你可以这样做

module Methods
  define_method :outer do 
    outer_var = 1
    define_method :inner do
      puts "defining inner"
      inner_var = outer_var +1
    end
    outer_var
  end
  extend self
end

Methods.outer 
#=> defining inner
#=> 1
Methods.inner 
#=> 2

当您在编写 DSL 等需要在方法之间共享范围的事情时，这很有用。但除此之外，你最好做其他任何事情，因为正如其他答案所说，每当调用 outer 时，都会重新定义 inner 。如果您想要这种行为，有时您可能会这样做，这是获得它的好方法。

Answer 5

Ruby 的方法是用令人困惑的 hack 来伪造它，这会让一些用户想知道“这到底是怎么回事？”，而不太好奇的人会简单地记住使用该东西所需的语法。如果您曾经使用过 Rake 或 Rails，那么您一定见过这种东西。

这是一个黑客：

def mlet(name,func)
  my_class = (Class.new do
                def initialize(name,func)
                  @name=name
                  @func=func
                end
                def method_missing(methname, *args)
                  puts "method_missing called on #{methname}"
                  if methname == @name
                    puts "Calling function #{@func}"
                    @func.call(*args)
                  else
                    raise NoMethodError.new "Undefined method `#{methname}' in mlet"
                  end
                end
              end)
  yield my_class.new(name,func)
end

它所做的是定义一个创建类并将其传递给块的顶级方法。该类使用method_missing 假装它具有您选择的名称的方法。它通过调用您必须提供的 lambda 来“实现”该方法。通过使用单字母名称命名对象，您可以最大限度地减少它需要的额外输入量（这与 Rails 在其schema.rb 中所做的事情相同）。 mlet 以 Common Lisp 形式 flet 命名，除了 f 代表“函数”，m 代表“方法”。

你可以这样使用它：

def outer
   mlet :inner, ->(x) { x*2 } do |c|
     c.inner 12
   end
end

可以制作一个类似的装置，允许在没有额外嵌套的情况下定义多个内部函数，但这需要你可能在 Rake 或 Rspec 的实现中找到的那种更丑陋的 hack。弄清楚 Rspec 的 let! 是如何工作的，会让你在创造如此可怕的可憎之物方面走得更远。

Answer 6

没有嵌套方法。都是实例方法，运行上面的方法后才定义为实例方法

irb(main):001:0> 
irb(main):002:1* class Test1
irb(main):003:2*   def meth1
irb(main):004:3*     def meth2
irb(main):005:3*       puts "Yay"
irb(main):006:2*     end
irb(main):007:3*     def meth3
irb(main):009:4*       def meth3_3
irb(main):010:4*         puts "Third level indented method"
irb(main):012:2*     end
irb(main):013:1*   end
irb(main):014:0> end
=> :meth1
irb(main):015:0> Test1.new.meth3_3
Traceback (most recent call last):
        4: from /home/khal/.rbenv/versions/2.7.1/bin/irb:23:in `<main>'
        3: from /home/khal/.rbenv/versions/2.7.1/bin/irb:23:in `load'
        2: from /home/khal/.rbenv/versions/2.7.1/lib/ruby/gems/2.7.0/gems/irb-1.2.3/exe/irb:11:in `<top (required)>'
        1: from (irb):15
NoMethodError (undefined method `meth3_3' for #<Test1:0x0000562ae163ce48>)
Did you mean?  meth1
irb(main):016:0> Test1.new.meth3
Traceback (most recent call last):
        5: from /home/khal/.rbenv/versions/2.7.1/bin/irb:23:in `<main>'
        4: from /home/khal/.rbenv/versions/2.7.1/bin/irb:23:in `load'
        3: from /home/khal/.rbenv/versions/2.7.1/lib/ruby/gems/2.7.0/gems/irb-1.2.3/exe/irb:11:in `<top (required)>'
        2: from (irb):15
        1: from (irb):16:in `rescue in irb_binding'
NoMethodError (undefined method `meth3' for #<Test1:0x0000562ae1328658>)
Did you mean?  meth1
               method
irb(main):017:0> Test1.new.meth2
Traceback (most recent call last):
        5: from /home/khal/.rbenv/versions/2.7.1/bin/irb:23:in `<main>'
        4: from /home/khal/.rbenv/versions/2.7.1/bin/irb:23:in `load'
        3: from /home/khal/.rbenv/versions/2.7.1/lib/ruby/gems/2.7.0/gems/irb-1.2.3/exe/irb:11:in `<top (required)>'
        2: from (irb):16
        1: from (irb):17:in `rescue in irb_binding'
NoMethodError (undefined method `meth2' for #<Test1:0x0000562ae163df78>)
Did you mean?  meth1
               method
irb(main):018:0> Test1.new.meth1
=> :meth3
irb(main):019:0> Test1.new.meth3_3
Traceback (most recent call last):
        4: from /home/khal/.rbenv/versions/2.7.1/bin/irb:23:in `<main>'
        3: from /home/khal/.rbenv/versions/2.7.1/bin/irb:23:in `load'
        2: from /home/khal/.rbenv/versions/2.7.1/lib/ruby/gems/2.7.0/gems/irb-1.2.3/exe/irb:11:in `<top (required)>'
        1: from (irb):19
NoMethodError (undefined method `meth3_3' for #<Test1:0x0000562ae2568688>)
Did you mean?  meth3
irb(main):020:0> Test1.new.meth3
Method Drei
=> :meth3_3
irb(main):021:0> Test1.new.meth3_3
Third level indented method
=> nil
irb(main):022:0> 

如果您最初检查实例方法，您会得到：

irb(main):019:0> Test1.instance_methods
=> [:meth1, :dup, ...]

分步运行后：

> Test1.instance_methods
=> [:meth3_3, :meth3, :meth1, :meth2,...]

Answer 7

:-D

Ruby 有嵌套的方法，只是它们没有按照您的期望进行操作

1.9.3p484 :001 > def kme; 'kme'; def foo; 'foo'; end; end              
 => nil 
1.9.3p484 :003 >   self.methods.include? :kme
 => true 
1.9.3p484 :004 > self.methods.include? :foo
 => false 
1.9.3p484 :005 > kme
 => nil 
1.9.3p484 :006 > self.methods.include? :foo
 => true 
1.9.3p484 :007 > foo
 => "foo"