blocks|key|803406|text|不，不，Ruby确实有嵌套的方法。请检查以下内容：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|803407|def+outer_method(arg)
++++outer_variable+=+"y"
++++inner_method+=+lambda+{
++++++puts+arg
++++++puts+outer_variable
++++}
++++inner_method[]
end

outer_method+"x"+#+prints+"x",+"y"|code-block|syntax|javascript|803408|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

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

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

outer_method "x" # prints "x", "y"
</code></pre>

blocks|key|803472|text|:-D|type|unstyled|depth|inlineStyleRanges|entityRanges|data|803473|Ruby有嵌套的方法，只是它们不会做你期望它们做的事情|803474|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"+|code-block|syntax|javascript|803475|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

:-D

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

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

blocks|key|803543|text|你可以这样做|type|unstyled|depth|inlineStyleRanges|entityRanges|data|803544|module+Methods
++define_method+:outer+do+
++++outer_var+=+1
++++define_method+:inner+do
++++++puts+"defining+inner"
++++++inner_var+=+outer_var+%2B1
++++end
++++outer_var
++end
++extend+self
end

Methods.outer+
#=>+defining+inner
#=>+1
Methods.inner+
#=>+2|code-block|syntax|javascript|803545|当你在写需要在方法之间共享作用域的DSL时，这是很有用的。但在其他方面，您最好做其他事情，因为正如其他答案所说，每当调用outer时，inner都会被重新定义。如果你想要这个行为，有时你可能会，这是一个获得它的好方法。|offset|length|style|CODE|803546|entityMap^0|0|0|1O|5|1V|5|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

You can do something like this

<pre><code>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 
#=&gt; defining inner
#=&gt; 1
Methods.inner 
#=&gt; 2
</code></pre>

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, <code>inner</code> is redefined whenever <code>outer</code> is invoked. If you want this behavior, and you sometimes might, this is a good way to get it.

blocks|key|1018345|text|实际上，这是可能的。为此，您可以使用procs/lambda。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1018346|def+test(value)
++inner+=+->()+{
++++value+*+value
++}
++inner.call()
end|code-block|syntax|javascript|1018347|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

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

<pre><code>def test(value)
 inner = -&gt;() {
 value * value
 }
 inner.call()
end
</code></pre>

blocks|key|803677|text|Ruby的方式是用令人困惑的黑客来伪装它，这会让一些用户想知道“这他妈的是怎么工作的？”，而不那么好奇的人会简单地记住使用这个东西所需的语法。如果你曾经使用过Rake或Rails，你一定见过这种东西。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|803678|下面就是这样的一个技巧：|803679|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|code-block|syntax|javascript|803680|它所做的是定义一个顶级方法，该方法创建一个类并将其传递给一个块。该类使用method_missing来假装它有一个与您选择的名称相同的方法。它通过调用您必须提供的lambda来“实现”该方法。通过使用一个字母的名称来命名对象，可以最大限度地减少它所需的额外输入量(这与Rails在其schema.rb中所做的事情相同)。mlet是以Common+Lisp+form+flet命名的，除了f代表“函数”，m代表“方法”。|offset|length|style|CODE|803681|您可以这样使用它：|803682|def+outer
+++mlet+:inner,+->(x)+{+x*2+}+do+%7Cc%7C
+++++c.inner+12
+++end
end|803683|也可以做一个类似的装置，允许定义多个内部函数，而不需要额外的嵌套，但这需要更丑陋的技巧，就像你在Rake或Rspec的实现中发现的那样。弄清楚Rspec的let!是如何工作的，这会让你有很长的路要走，才能创造出如此令人厌恶的东西。|803684|entityMap^0|0|0|0|10|E|3X|9|4G|4|53|4|5D|1|5L|1|0|0|0|25|4|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@$K|10|L|11|M|N]|$K|12|L|13|M|N]|$K|14|L|15|M|N]|$K|16|L|17|M|N]|$K|18|L|19|M|N]|$K|1A|L|1B|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|1D|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|1E|8|@$K|1F|L|1G|M|N]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|V|$]]

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:

<pre><code>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
</code></pre>

What that does is define a top-level method that creates a class and passes it to a block. The class uses <code>method_missing</code> 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 <code>schema.rb</code>). <code>mlet</code> is named after the Common Lisp form <code>flet</code>, except where <code>f</code> stands for "function", <code>m</code> stands for "method".

You use it like this:

<pre><code>def outer
 mlet :inner, -&gt;(x) { x*2 } do |c|
 c.inner 12
 end
end
</code></pre>

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 <code>let!</code> works would get you a long way towards being able to create such a horrible abomination.

blocks|key|1018517|text|没有嵌套的方法。所有方法都是实例方法，只有在运行它们上面的方法后才会定义为实例方法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1018518|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>+|code-block|syntax|javascript|1018519|最初，如果你检查实例方法，你会得到：|1018520|irb(main):019:0>+Test1.instance_methods
=>+[:meth1,+:dup,+...]|1018521|在步骤中运行它们之后：|1018522|>+Test1.instance_methods
=>+[:meth3_3,+:meth3,+:meth1,+:meth2,...]|1018523|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

There are no nested methods. All are instance methods are only defined as instance methods after running the method above them
<pre><code>irb(main):001:0&gt; 
irb(main):002:1* class Test1
irb(main):003:2* def meth1
irb(main):004:3* def meth2
irb(main):005:3* puts &quot;Yay&quot;
irb(main):006:2* end
irb(main):007:3* def meth3
irb(main):009:4* def meth3_3
irb(main):010:4* puts &quot;Third level indented method&quot;
irb(main):012:2* end
irb(main):013:1* end
irb(main):014:0&gt; end
=&gt; :meth1
irb(main):015:0&gt; Test1.new.meth3_3
Traceback (most recent call last):
 4: from /home/khal/.rbenv/versions/2.7.1/bin/irb:23:in `&lt;main&gt;'
 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 `&lt;top (required)&gt;'
 1: from (irb):15
NoMethodError (undefined method `meth3_3' for #&lt;Test1:0x0000562ae163ce48&gt;)
Did you mean? meth1
irb(main):016:0&gt; Test1.new.meth3
Traceback (most recent call last):
 5: from /home/khal/.rbenv/versions/2.7.1/bin/irb:23:in `&lt;main&gt;'
 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 `&lt;top (required)&gt;'
 2: from (irb):15
 1: from (irb):16:in `rescue in irb_binding'
NoMethodError (undefined method `meth3' for #&lt;Test1:0x0000562ae1328658&gt;)
Did you mean? meth1
 method
irb(main):017:0&gt; Test1.new.meth2
Traceback (most recent call last):
 5: from /home/khal/.rbenv/versions/2.7.1/bin/irb:23:in `&lt;main&gt;'
 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 `&lt;top (required)&gt;'
 2: from (irb):16
 1: from (irb):17:in `rescue in irb_binding'
NoMethodError (undefined method `meth2' for #&lt;Test1:0x0000562ae163df78&gt;)
Did you mean? meth1
 method
irb(main):018:0&gt; Test1.new.meth1
=&gt; :meth3
irb(main):019:0&gt; Test1.new.meth3_3
Traceback (most recent call last):
 4: from /home/khal/.rbenv/versions/2.7.1/bin/irb:23:in `&lt;main&gt;'
 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 `&lt;top (required)&gt;'
 1: from (irb):19
NoMethodError (undefined method `meth3_3' for #&lt;Test1:0x0000562ae2568688&gt;)
Did you mean? meth3
irb(main):020:0&gt; Test1.new.meth3
Method Drei
=&gt; :meth3_3
irb(main):021:0&gt; Test1.new.meth3_3
Third level indented method
=&gt; nil
irb(main):022:0&gt; 

</code></pre>
initialy if your check the instance methods, you get:
<pre><code>irb(main):019:0&gt; Test1.instance_methods
=&gt; [:meth1, :dup, ...]
</code></pre>
After running them in steps:
<pre><code>&gt; Test1.instance_methods
=&gt; [:meth3_3, :meth3, :meth1, :meth2,...]
</code></pre>

I have a method inside of a method. The interior method depends on a variable loop that is being run. Is that a bad idea?

Is it possible to have Methods inside Methods?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

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

问有可能在方法中包含方法吗？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问有可能在方法中包含方法吗？EN