blocks|key|4401669|text|我认为有几种方法可以做你想做的事情。一种方法是打开类并为旧的实现添加别名：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4401670|class+MyClass
++def+method1
++++1
++end
end

class+MyClass
++alias_method+:old_method1,+:method1
++def+method1
++++old_method1+%2B+1
++end
end

MyClass.new.method1
+=>+2+|code-block|syntax|javascript|4401671|这是monkey+patching的一种形式，所以最好适度地使用这个习惯用法。此外，有时需要的是一个单独的辅助方法，该方法包含通用功能。|offset|length|4401672|编辑：有关更全面的选项集，请参阅Jörg+W+Mittag的答案。|style|BOLD|4401673|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Monkey_patch^0|0|0|2|F|0|0|0|2|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@$I|Z|J|10|1|11]]|A|$]]|$1|K|3|L|5|6|7|12|8|@$I|13|J|14|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

I think there are several ways to do what you're wanting to do. One is to open the class and alias the old implementation:

<pre><code>class MyClass
 def method1
 1
 end
end

class MyClass
 alias_method :old_method1, :method1
 def method1
 old_method1 + 1
 end
end

MyClass.new.method1
 =&gt; 2 
</code></pre>

This is a form of <a href="http://en.wikipedia.org/wiki/Monkey_patch" rel="noreferrer">monkey patching</a>, so probably best to make use of the idiom in moderation. Also, sometimes what is wanted is a separate helper method that holds the common functionality.

EDIT: See Jörg W Mittag's answer for a more comprehensive set of options.

blocks|key|50013|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|50014|我发现instance_eval是覆盖核心类中方法的好方法，|blockquote|50015|50016|50017|您不是在重写。您正在覆盖aka+monkeypatching。|50018|50019|，但有时我想避免重写整个方法，而只遵循原始方法。|50020|50021|50022|你不能遵从原来的方法。没有原创的方法。你把它改写了。|50023|50024|，但使用instance_eval似乎会将super方法从查找路径中删除。|offset|length|style|CODE|50025|50026|50027|在您的示例中没有继承。super甚至都不起作用。|50028|有关可能的解决方案和替代方案，请参阅此答案：When+monkey+patching+a+method,+can+you+call+the+overridden+method+from+the+new+implementation?|50029|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/4470108/when-monkey-patching-a-method-can-you-call-the-overridden-method-from-the-new-i/4471202#4471202^0|0|0|0|0|0|0|0|0|0|0|0|L|5|0|0|0|B|5|0|M|2M|0|0^^$0|@$1|2|3|-4|4|5|6|19|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|1A|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|1B|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|1C|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|1D|7|@]|8|@]|9|$]]|$1|H|3|-4|4|5|6|1E|7|@]|8|@]|9|$]]|$1|I|3|J|4|C|6|1F|7|@]|8|@]|9|$]]|$1|K|3|-4|4|5|6|1G|7|@]|8|@]|9|$]]|$1|L|3|-4|4|5|6|1H|7|@]|8|@]|9|$]]|$1|M|3|N|4|5|6|1I|7|@]|8|@]|9|$]]|$1|O|3|-4|4|5|6|1J|7|@]|8|@]|9|$]]|$1|P|3|Q|4|C|6|1K|7|@$R|1L|S|1M|T|U]]|8|@]|9|$]]|$1|V|3|-4|4|5|6|1N|7|@]|8|@]|9|$]]|$1|W|3|-4|4|5|6|1O|7|@]|8|@]|9|$]]|$1|X|3|Y|4|5|6|1P|7|@$R|1Q|S|1R|T|U]]|8|@]|9|$]]|$1|Z|3|10|4|5|6|1S|7|@]|8|@$R|1T|S|1U|1|1V]]|9|$]]|$1|11|3|-4|4|5|6|1W|7|@]|8|@]|9|$]]]|12|$13|$4|14|15|16|9|$17|18]]]]

<blockquote>
 I'm finding that instance_eval is a good way to override methods in the core Class,
</blockquote>

You are not overriding. You are overwriting aka monkeypatching.

<blockquote>
 but sometimes I would like to avoid re-writing the entire method, and just defer to the original method.
</blockquote>

You can't defer to the original method. There is no original method. You overwrote it.

<blockquote>
 But using instance_eval seems to take the <code>super</code> method out of the lookup path.
</blockquote>

There is no inheritance in your example. <code>super</code> doesn't even come into play.

See this answer for possible solutions and alternatives: <a href="https://stackoverflow.com/questions/4470108/when-monkey-patching-a-method-can-you-call-the-overridden-method-from-the-new-i/4471202#4471202">When monkey patching a method, can you call the overridden method from the new implementation?</a>

blocks|key|49196|text|方法Object#instance_eval允许您将self设置为某个任意对象，使用评估块中的代码，然后重置self。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|49197|module+CustomClient
++def+self.included+base
++++base.instance_eval+do
++++++puts+"about+to+def+account_balance+in+#{self}"
++++++def+account_balance
++++++++super
++++++end
++++end
++end
end

class+Client
++++include+CustomClient+#=>+about+to+def+account_balance+in+Client
end|code-block|syntax|javascript|49198|正如您所看到的，def+account_balance是在Client类的上下文中计算的，Client是包含模块的宿主类，因此account_balance成为Client的单例方法(也称为类方法)：|offset|length|style|CODE|49199|print+'Client.singleton_methods+:+'
p+Client.singleton_methods+#=>+Client.singleton_methods+:+[:account_balance]|49200|Client.new.account_balance不能工作，因为它不是一个实例方法。|49201|49202|“我有一个应用程序，它将模块包含到核心类中”|blockquote|49203|49204|49205|由于您没有提供太多细节，我设想了以下基础架构：|49206|class+SuperClient
++++def+account_balance
++++++++puts+'SuperClient#account_balance'
++++end
end

class+Client+<+SuperClient
++++include+CustomClient
end|49207|现在用class_eval替换instance_eval。在拾取器中，class_eval的设置就像在类定义的主体中一样，因此方法定义将定义实例方法。|49208|module+CustomClient
...
+++base.class_eval+do
...

print+'Client.new.account_balance+:+'
Client.new.account_balance|49209|输出：|49210|++#=>+from+include+CustomClient+:
about+to+def+account_balance+in+Client+#=>+as+class+Client,+in+the+body+of+Client
Client.singleton_methods+:+[]
Client.new.account_balance+:+SuperClient#account_balance+#=>+from+super|49211|"But+using+instance_eval+seems+to+take+the+super+method+out+of+the+lookup+path."|49212|super已经奏效了。问题出在instance_eval上。|49213|entityMap^0|0|0|8|J|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|5|0^^$0|@$1|2|3|4|5|6|7|1E|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1G|8|@$I|1H|J|1I|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|1J|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1K|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]|$1|R|3|S|5|T|7|1M|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1P|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1Q|8|@]|9|@]|A|$E|F]]|$1|10|3|11|5|6|7|1R|8|@]|9|@]|A|$]]|$1|12|3|13|5|D|7|1S|8|@]|9|@]|A|$E|F]]|$1|14|3|15|5|6|7|1T|8|@]|9|@]|A|$]]|$1|16|3|17|5|D|7|1U|8|@]|9|@]|A|$E|F]]|$1|18|3|19|5|D|7|1V|8|@]|9|@]|A|$E|F]]|$1|1A|3|1B|5|6|7|1W|8|@$I|1X|J|1Y|K|L]]|9|@]|A|$]]|$1|1C|3|-4|5|6|7|1Z|8|@]|9|@]|A|$]]]|1D|$]]

[from the Pickaxe] The method Object#instance_eval lets you set self to be some arbitrary object, evaluates the code in a block with, and then resets self.

<pre><code>module CustomClient
 def self.included base
 base.instance_eval do
 puts "about to def account_balance in #{self}"
 def account_balance
 super
 end
 end
 end
end

class Client
 include CustomClient #=&gt; about to def account_balance in Client
end
</code></pre>

As you can see, <code>def account_balance</code> is evaluated in the context of class Client, the host class which includes the module, hence account_balance becomes a singleton method (aka class method) of Client :

<pre><code>print 'Client.singleton_methods : '
p Client.singleton_methods #=&gt; Client.singleton_methods : [:account_balance]
</code></pre>

Client.new.account_balance won't work because it's not an instance method.

<blockquote>
 "I have an app that includes modules into core Classes"
</blockquote>

As you don't give much details, I have imagined the following infrastructure :

<pre><code>class SuperClient
 def account_balance
 puts 'SuperClient#account_balance'
 end
end

class Client &lt; SuperClient
 include CustomClient
end
</code></pre>

Now replace instance_eval by class_eval. [from the Pickaxe] class_eval sets things up as if you were in the body of a class definition, so method definitions will define instance methods.

<pre><code>module CustomClient
...
 base.class_eval do
...

print 'Client.new.account_balance : '
Client.new.account_balance
</code></pre>

Output :

<pre><code> #=&gt; from include CustomClient :
about to def account_balance in Client #=&gt; as class Client, in the body of Client
Client.singleton_methods : []
Client.new.account_balance : SuperClient#account_balance #=&gt; from super
</code></pre>

 

<pre><code>"But using instance_eval seems to take the super method out of the lookup path."
</code></pre>

<code>super</code> has worked. The problem was instance_eval.

blocks|key|49245|text|正如您所说，必须谨慎使用alias_method。给出这个人为的例子：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|49246|module+CustomClient
...++++
++++host.class_eval+do
++++++alias+:old_account_balance+:account_balance
++++++def+account_balance+...
++++++++old_account_balance
++++++end
...
class+CoreClass
++++def+old_account_balance+...+defined+here+or+in+a+superclass+or
++++++++++++++++++++++++++++++++in+another+included+module
++++def+account_balance
++++++++#+some+new+stuff+...
++++++++old_account_balance+#+some+old+stuff+...
++++end
++++include+CustomClient
end|code-block|syntax|javascript|49247|你最终会得到一个无限循环，因为在别名之后，old_account_balance是account_balance的副本，它现在称自己为：|49248|$+ruby+-w+t4.rb+
t4.rb:21:+warning:+method+redefined;+discarding+old+old_account_balance
t4.rb:2:+warning:+previous+definition+of+old_account_balance+was+here
[+output+of+puts+removed+]
t4.rb:6:+stack+level+too+deep+(SystemStackError)|49249|从十字架上看，这种技术alias_method的问题在于，您所依赖的并不是一个名为old_xxx的现有方法。一个更好的选择是使用方法对象，它实际上是匿名的。|49250|话虽如此，如果你拥有源代码，一个简单的别名就足够好了。但对于更一般的情况，我将使用Jörg的方法包装技术。|49251|class+CoreClass
++++def+account_balance
++++++++puts+'CoreClass#account_balance,+stuff+deferred+to+the+original+method.'
++++end
end

module+CustomClient
++def+self.included+host
++++@is_defined_account_balance+=+host.new.respond_to?+:account_balance
++++puts+"is_defined_account_balance=#{@is_defined_account_balance}"
++++++++#+pass+this+flag+from+CustomClient+to+host+:
++++host.instance_variable_set(:@is_defined_account_balance,
++++++++++++++++++++++++++++++++@is_defined_account_balance)
++++host.class_eval+do
++++++old_account_balance+=+instance_method(:account_balance)+if
++++++++++++++++@is_defined_account_balance
++++++define_method(:account_balance)+do+%7C*args%7C
++++++++puts+'CustomClient#account_balance,+additional+stuff'
++++++++++++#+like+super+:
++++++++old_account_balance.bind(self).call(*args)+if
++++++++++++++++self.class.instance_variable_get(:@is_defined_account_balance)
++++++end
++++end
++end
end

class+CoreClass
++++include+CustomClient
end

print+'CoreClass.new.account_balance+:+'
CoreClass.new.account_balance|49252|输出：|49253|$+ruby+-w+t5.rb+
is_defined_account_balance=true
CoreClass.new.account_balance+:+CustomClient#account_balance,+additional+stuff
CoreClass#account_balance,+stuff+deferred+to+the+original+method.|49254|为什么不是类变量@@is_defined_account_balance呢？从选择器中，包含include的模块或类定义可以访问它包含的模块的常量、类变量和实例方法。|49255|它将避免将其从CustomClient传递到主机，并简化测试：|49256|++++old_account_balance+if+@@is_defined_account_balance+#+=+super|49257|但有些人不喜欢类变量，也不喜欢全局变量。|49258|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|16|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|18|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|19|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|1B|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1D|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1E|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|10|3|11|5|6|7|1G|8|@]|9|@]|A|$]]|$1|12|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|13|$]]

As you say, alias_method must be used carefully. Given this contrived example :

<pre><code>module CustomClient
... 
 host.class_eval do
 alias :old_account_balance :account_balance
 def account_balance ...
 old_account_balance
 end
...
class CoreClass
 def old_account_balance ... defined here or in a superclass or
 in another included module
 def account_balance
 # some new stuff ...
 old_account_balance # some old stuff ...
 end
 include CustomClient
end
</code></pre>

you end up with an infinite loop because, after alias, old_account_balance is a copy of account_balance, which now calls itself :

<pre><code>$ ruby -w t4.rb 
t4.rb:21: warning: method redefined; discarding old old_account_balance
t4.rb:2: warning: previous definition of old_account_balance was here
[ output of puts removed ]
t4.rb:6: stack level too deep (SystemStackError)
</code></pre>

[from the Pickaxe] The problem with this technique [alias_method] is that you’re relying on there not being an existing method called old_xxx. A better alternative is to make use of method objects, which are effectively anonymous.

Having said that, if you own the source code, a simple alias is good enough. But for a more general case, i'll use Jörg's Method Wrapping technique.

<pre><code>class CoreClass
 def account_balance
 puts 'CoreClass#account_balance, stuff deferred to the original method.'
 end
end

module CustomClient
 def self.included host
 @is_defined_account_balance = host.new.respond_to? :account_balance
 puts "is_defined_account_balance=#{@is_defined_account_balance}"
 # pass this flag from CustomClient to host :
 host.instance_variable_set(:@is_defined_account_balance,
 @is_defined_account_balance)
 host.class_eval do
 old_account_balance = instance_method(:account_balance) if
 @is_defined_account_balance
 define_method(:account_balance) do |*args|
 puts 'CustomClient#account_balance, additional stuff'
 # like super :
 old_account_balance.bind(self).call(*args) if
 self.class.instance_variable_get(:@is_defined_account_balance)
 end
 end
 end
end

class CoreClass
 include CustomClient
end

print 'CoreClass.new.account_balance : '
CoreClass.new.account_balance
</code></pre>

Output :

<pre><code>$ ruby -w t5.rb 
is_defined_account_balance=true
CoreClass.new.account_balance : CustomClient#account_balance, additional stuff
CoreClass#account_balance, stuff deferred to the original method.
</code></pre>

Why not a class variable @@is_defined_account_balance ? [from the Pickaxe] The module or class definition containing the include gains access to the constants, class variables, and instance methods of the module it includes. 
It would avoid passing it from CustomClient to host and simplify the test :

<pre><code> old_account_balance if @@is_defined_account_balance # = super
</code></pre>

But some dislike class variables as much as global variables.

I have an app that includes modules into core Classes for adding client customizations.

I'm finding that class_eval is a good way to override methods in the core Class, but sometimes I would like to avoid re-writing the entire method, and just defer to the original method.

For example, if I have a method called <code>account_balance</code>, it would be nice to do something like this in my module (i.e. the module that gets included into the Class):

<pre><code>module CustomClient
 def self.included base
 base.class_eval do
 def account_balance
 send_alert_email if balance &lt; min
 super # Then this would just defer the rest of the logic defined in the original class
 end
 end
 end
end
</code></pre>

But using class_eval seems to take the <code>super</code> method out of the lookup path.

Does anyone know how to work around this?

Thanks!

Using super with class_eval

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我有一个应用程序，其中包括模块到核心类，以添加客户端自定义。我发现class_eval是覆盖核心类中方法的好方法，但有时我希望避免重写整个方法，而只遵循原始方法。例如，如果我有一个名为account_balance的方法，那么在我的模块(即包含在类中的模块)中做一些类似的事情会很好：module CustomClien...

问结合使用super和class_eval
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问结合使用super和class_evalEN