是否可能在方法中包含方法？

UPDATE: Since this answer seems to have gotten some interest lately, I wanted to point out that there is discussion on the Ruby issue tracker to remove the feature discussed here, namely to forbid having method definitions inside a method body.

No, Ruby doesn't have nested methods.

You can do something like this:

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


Test1.new.meth1

But that is not a nested method. I repeat: Ruby does not have nested methods.

What this is, is a dynamic method definition. When you run meth1, the body of meth1 will be executed. The body just happens to define a method named meth2, which is why after running meth1 once, you can call meth2.

But where is meth2 defined? Well, it's obviously not defined as a nested method, since there are no nested methods in Ruby. It's defined as an instance method of Test1:

Test1.new.meth2
# Yay

Also, it will obviously be redefined every time you run 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

In short: no, Ruby does not support nested methods.

Note also that in Ruby, method bodies cannot be closures, only block bodies can. This pretty much eliminates the major use case for nested methods, since even if Ruby supported nested methods, you couldn't use the outer method's variables in the nested method.

UPDATE CONTINUED: at a later stage, then, this syntax might be re-used for adding nested methods to Ruby, which would behave the way I described: they would be scoped to their containing method, i.e. invisible and inaccessible outside of their containing method body. And possibly, they would have access to their containing method's lexical scope. However, if you read the discussion I linked above, you can observe that matz is heavily against nested methods (but still for removing nested method definitions).

No, no, Ruby does have nested methods. Check this:

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


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

:-D

Ruby has nested methods, only they don't do what you'd expect them to

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"

You can do something like this

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

This is useful when you're doing things like writing DSLs which require sharing of scope between methods. But otherwise, you're much better off doing anything else, because as the other answers said, inner is redefined whenever outer is invoked. If you want this behavior, and you sometimes might, this is a good way to get it.

Actually it's possible. You can use procs/lambda for this.

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

The Ruby way is to fake it with confusing hacks that will have some users wondering "How in the fuck does this even work?", while the less curious will simply memorize the syntax needed to use the thing. If you've ever used Rake or Rails, you've seen this kind of thing.

Here is such a hack:

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

What that does is define a top-level method that creates a class and passes it to a block. The class uses method_missing to pretend that it has a method with the name you chose. It "implements" the method by calling the lambda you must provide. By naming the object with a one-letter name, you can minimize the amount of extra typing that it requires (which is the same thing that Rails does in its schema.rb). mlet is named after the Common Lisp form flet, except where f stands for "function", m stands for "method".

You use it like this:

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

It is possible to make a similar contraption that allows for multiple inner functions to be defined without additional nesting, but that requires an even uglier hack of the sort you might find in Rake's or Rspec's implementation. Figuring out how Rspec's let! works would get you a long way towards being able to create such a horrible abomination.

There are no nested methods. All are instance methods are only defined as instance methods after running the method above them

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>

initialy if your check the instance methods, you get:

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

After running them in steps:

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